diff --git a/services/autorust/codegen/examples/gen_svc.rs b/services/autorust/codegen/examples/gen_svc.rs
index ae459a955d..c7d53c4884 100644
--- a/services/autorust/codegen/examples/gen_svc.rs
+++ b/services/autorust/codegen/examples/gen_svc.rs
@@ -10,7 +10,7 @@ use std::{collections::HashSet, fs, path::PathBuf};
 
 const OUTPUT_FOLDER: &str = "../svc";
 
-const ONLY_SERVICES: &[&str] = &["batch"];
+const ONLY_SERVICES: &[&str] = &[];
 
 const SKIP_SERVICES: &[&str] = &[
     "deviceupdate",            // missing field `authorizationUrl`
diff --git a/services/svc/appconfiguration/Cargo.toml b/services/svc/appconfiguration/Cargo.toml
new file mode 100644
index 0000000000..6772bc693f
--- /dev/null
+++ b/services/svc/appconfiguration/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_appconfiguration"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2019-07"]
+"package-2019-07" = []
diff --git a/services/svc/appconfiguration/src/lib.rs b/services/svc/appconfiguration/src/lib.rs
new file mode 100644
index 0000000000..6d548335c8
--- /dev/null
+++ b/services/svc/appconfiguration/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2019-07")]
+mod package_2019_07;
+use azure_core::setters;
+#[cfg(feature = "package-2019-07")]
+pub use package_2019_07::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/appconfiguration/src/package_2019_07/mod.rs b/services/svc/appconfiguration/src/package_2019_07/mod.rs
new file mode 100644
index 0000000000..cadfdca78f
--- /dev/null
+++ b/services/svc/appconfiguration/src/package_2019_07/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "1.0";
diff --git a/services/svc/appconfiguration/src/package_2019_07/models.rs b/services/svc/appconfiguration/src/package_2019_07/models.rs
new file mode 100644
index 0000000000..2b46aa2825
--- /dev/null
+++ b/services/svc/appconfiguration/src/package_2019_07/models.rs
@@ -0,0 +1,67 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Key {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyValue {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub content_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub last_modified: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub locked: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Label {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Error {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub detail: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub items: Vec<Key>,
+    #[serde(rename = "@nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyValueListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub items: Vec<KeyValue>,
+    #[serde(rename = "@nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LabelListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub items: Vec<Label>,
+    #[serde(rename = "@nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
diff --git a/services/svc/appconfiguration/src/package_2019_07/operations.rs b/services/svc/appconfiguration/src/package_2019_07/operations.rs
new file mode 100644
index 0000000000..b8e5c50525
--- /dev/null
+++ b/services/svc/appconfiguration/src/package_2019_07/operations.rs
@@ -0,0 +1,1090 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub async fn get_keys(
+    operation_config: &crate::OperationConfig,
+    name: Option<&str>,
+    sync_token: Option<&str>,
+    after: Option<&str>,
+    accept_datetime: Option<&str>,
+) -> std::result::Result<KeyListResult, get_keys::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/keys", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_keys::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_keys::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(name) = name {
+        url.query_pairs_mut().append_pair("name", name);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(after) = after {
+        url.query_pairs_mut().append_pair("After", after);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_keys::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_keys::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: KeyListResult =
+                serde_json::from_slice(rsp_body).map_err(|source| get_keys::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| get_keys::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_keys::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_keys {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn check_keys(
+    operation_config: &crate::OperationConfig,
+    name: Option<&str>,
+    sync_token: Option<&str>,
+    after: Option<&str>,
+    accept_datetime: Option<&str>,
+) -> std::result::Result<(), check_keys::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/keys", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(check_keys::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::HEAD);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(check_keys::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(name) = name {
+        url.query_pairs_mut().append_pair("name", name);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(after) = after {
+        url.query_pairs_mut().append_pair("After", after);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(check_keys::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(check_keys::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => Ok(()),
+        status_code => Err(check_keys::Error::DefaultResponse { status_code }),
+    }
+}
+pub mod check_keys {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse { status_code: http::StatusCode },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_key_values(
+    operation_config: &crate::OperationConfig,
+    key: Option<&str>,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    after: Option<&str>,
+    accept_datetime: Option<&str>,
+    select: &Vec<&str>,
+) -> std::result::Result<KeyValueListResult, get_key_values::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/kv", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_key_values::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_key_values::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(key) = key {
+        url.query_pairs_mut().append_pair("key", key);
+    }
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(after) = after {
+        url.query_pairs_mut().append_pair("After", after);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_key_values::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_key_values::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: KeyValueListResult =
+                serde_json::from_slice(rsp_body).map_err(|source| get_key_values::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| get_key_values::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_key_values::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_key_values {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn check_key_values(
+    operation_config: &crate::OperationConfig,
+    key: Option<&str>,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    after: Option<&str>,
+    accept_datetime: Option<&str>,
+    select: &Vec<&str>,
+) -> std::result::Result<(), check_key_values::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/kv", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(check_key_values::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::HEAD);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(check_key_values::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(key) = key {
+        url.query_pairs_mut().append_pair("key", key);
+    }
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(after) = after {
+        url.query_pairs_mut().append_pair("After", after);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(check_key_values::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(check_key_values::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => Ok(()),
+        status_code => Err(check_key_values::Error::DefaultResponse { status_code }),
+    }
+}
+pub mod check_key_values {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse { status_code: http::StatusCode },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_key_value(
+    operation_config: &crate::OperationConfig,
+    key: &str,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    accept_datetime: Option<&str>,
+    if_match: Option<&str>,
+    if_none_match: Option<&str>,
+    select: &Vec<&str>,
+) -> std::result::Result<KeyValue, get_key_value::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/kv/{}", operation_config.base_path(), key);
+    let mut url = url::Url::parse(url_str).map_err(get_key_value::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_key_value::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    if let Some(if_match) = if_match {
+        req_builder = req_builder.header("If-Match", if_match);
+    }
+    if let Some(if_none_match) = if_none_match {
+        req_builder = req_builder.header("If-None-Match", if_none_match);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_key_value::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_key_value::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: KeyValue =
+                serde_json::from_slice(rsp_body).map_err(|source| get_key_value::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| get_key_value::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_key_value::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_key_value {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn put_key_value(
+    operation_config: &crate::OperationConfig,
+    key: &str,
+    label: Option<&str>,
+    entity: Option<&KeyValue>,
+    sync_token: Option<&str>,
+    if_match: Option<&str>,
+    if_none_match: Option<&str>,
+) -> std::result::Result<KeyValue, put_key_value::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/kv/{}", operation_config.base_path(), key);
+    let mut url = url::Url::parse(url_str).map_err(put_key_value::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::PUT);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(put_key_value::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    let req_body = if let Some(entity) = entity {
+        azure_core::to_json(entity).map_err(put_key_value::Error::SerializeError)?
+    } else {
+        bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+    };
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(if_match) = if_match {
+        req_builder = req_builder.header("If-Match", if_match);
+    }
+    if let Some(if_none_match) = if_none_match {
+        req_builder = req_builder.header("If-None-Match", if_none_match);
+    }
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(put_key_value::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(put_key_value::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: KeyValue =
+                serde_json::from_slice(rsp_body).map_err(|source| put_key_value::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| put_key_value::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(put_key_value::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod put_key_value {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn delete_key_value(
+    operation_config: &crate::OperationConfig,
+    key: &str,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    if_match: Option<&str>,
+) -> std::result::Result<delete_key_value::Response, delete_key_value::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/kv/{}", operation_config.base_path(), key);
+    let mut url = url::Url::parse(url_str).map_err(delete_key_value::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::DELETE);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(delete_key_value::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(if_match) = if_match {
+        req_builder = req_builder.header("If-Match", if_match);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(delete_key_value::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(delete_key_value::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: KeyValue =
+                serde_json::from_slice(rsp_body).map_err(|source| delete_key_value::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(delete_key_value::Response::Ok200(rsp_value))
+        }
+        http::StatusCode::NO_CONTENT => Ok(delete_key_value::Response::NoContent204),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| delete_key_value::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(delete_key_value::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod delete_key_value {
+    use crate::{models, models::*};
+    #[derive(Debug)]
+    pub enum Response {
+        Ok200(KeyValue),
+        NoContent204,
+    }
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn check_key_value(
+    operation_config: &crate::OperationConfig,
+    key: &str,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    accept_datetime: Option<&str>,
+    if_match: Option<&str>,
+    if_none_match: Option<&str>,
+    select: &Vec<&str>,
+) -> std::result::Result<(), check_key_value::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/kv/{}", operation_config.base_path(), key);
+    let mut url = url::Url::parse(url_str).map_err(check_key_value::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::HEAD);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(check_key_value::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    if let Some(if_match) = if_match {
+        req_builder = req_builder.header("If-Match", if_match);
+    }
+    if let Some(if_none_match) = if_none_match {
+        req_builder = req_builder.header("If-None-Match", if_none_match);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(check_key_value::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(check_key_value::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => Ok(()),
+        status_code => Err(check_key_value::Error::DefaultResponse { status_code }),
+    }
+}
+pub mod check_key_value {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse { status_code: http::StatusCode },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_labels(
+    operation_config: &crate::OperationConfig,
+    name: Option<&str>,
+    sync_token: Option<&str>,
+    after: Option<&str>,
+    accept_datetime: Option<&str>,
+    select: &Vec<&str>,
+) -> std::result::Result<LabelListResult, get_labels::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/labels", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_labels::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_labels::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(name) = name {
+        url.query_pairs_mut().append_pair("name", name);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(after) = after {
+        url.query_pairs_mut().append_pair("After", after);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_labels::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_labels::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: LabelListResult =
+                serde_json::from_slice(rsp_body).map_err(|source| get_labels::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| get_labels::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_labels::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_labels {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn check_labels(
+    operation_config: &crate::OperationConfig,
+    name: Option<&str>,
+    sync_token: Option<&str>,
+    after: Option<&str>,
+    accept_datetime: Option<&str>,
+    select: &Vec<&str>,
+) -> std::result::Result<(), check_labels::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/labels", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(check_labels::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::HEAD);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(check_labels::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(name) = name {
+        url.query_pairs_mut().append_pair("name", name);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(after) = after {
+        url.query_pairs_mut().append_pair("After", after);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(check_labels::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(check_labels::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => Ok(()),
+        status_code => Err(check_labels::Error::DefaultResponse { status_code }),
+    }
+}
+pub mod check_labels {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse { status_code: http::StatusCode },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn put_lock(
+    operation_config: &crate::OperationConfig,
+    key: &str,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    if_match: Option<&str>,
+    if_none_match: Option<&str>,
+) -> std::result::Result<KeyValue, put_lock::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/locks/{}", operation_config.base_path(), key);
+    let mut url = url::Url::parse(url_str).map_err(put_lock::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::PUT);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(put_lock::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(if_match) = if_match {
+        req_builder = req_builder.header("If-Match", if_match);
+    }
+    if let Some(if_none_match) = if_none_match {
+        req_builder = req_builder.header("If-None-Match", if_none_match);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(put_lock::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(put_lock::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: KeyValue =
+                serde_json::from_slice(rsp_body).map_err(|source| put_lock::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| put_lock::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(put_lock::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod put_lock {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn delete_lock(
+    operation_config: &crate::OperationConfig,
+    key: &str,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    if_match: Option<&str>,
+    if_none_match: Option<&str>,
+) -> std::result::Result<KeyValue, delete_lock::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/locks/{}", operation_config.base_path(), key);
+    let mut url = url::Url::parse(url_str).map_err(delete_lock::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::DELETE);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(delete_lock::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(if_match) = if_match {
+        req_builder = req_builder.header("If-Match", if_match);
+    }
+    if let Some(if_none_match) = if_none_match {
+        req_builder = req_builder.header("If-None-Match", if_none_match);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(delete_lock::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(delete_lock::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: KeyValue =
+                serde_json::from_slice(rsp_body).map_err(|source| delete_lock::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| delete_lock::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(delete_lock::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod delete_lock {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_revisions(
+    operation_config: &crate::OperationConfig,
+    key: Option<&str>,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    after: Option<&str>,
+    accept_datetime: Option<&str>,
+    select: &Vec<&str>,
+) -> std::result::Result<KeyValueListResult, get_revisions::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/revisions", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_revisions::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_revisions::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(key) = key {
+        url.query_pairs_mut().append_pair("key", key);
+    }
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(after) = after {
+        url.query_pairs_mut().append_pair("After", after);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_revisions::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_revisions::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: KeyValueListResult =
+                serde_json::from_slice(rsp_body).map_err(|source| get_revisions::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: Error =
+                serde_json::from_slice(rsp_body).map_err(|source| get_revisions::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_revisions::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_revisions {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::Error,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn check_revisions(
+    operation_config: &crate::OperationConfig,
+    key: Option<&str>,
+    label: Option<&str>,
+    sync_token: Option<&str>,
+    after: Option<&str>,
+    accept_datetime: Option<&str>,
+    select: &Vec<&str>,
+) -> std::result::Result<(), check_revisions::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/revisions", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(check_revisions::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::HEAD);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(check_revisions::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(key) = key {
+        url.query_pairs_mut().append_pair("key", key);
+    }
+    if let Some(label) = label {
+        url.query_pairs_mut().append_pair("label", label);
+    }
+    if let Some(sync_token) = sync_token {
+        req_builder = req_builder.header("Sync-Token", sync_token);
+    }
+    if let Some(after) = after {
+        url.query_pairs_mut().append_pair("After", after);
+    }
+    if let Some(accept_datetime) = accept_datetime {
+        req_builder = req_builder.header("Accept-Datetime", accept_datetime);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(check_revisions::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(check_revisions::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => Ok(()),
+        status_code => Err(check_revisions::Error::DefaultResponse { status_code }),
+    }
+}
+pub mod check_revisions {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse { status_code: http::StatusCode },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
diff --git a/services/svc/applicationinsights/Cargo.toml b/services/svc/applicationinsights/Cargo.toml
new file mode 100644
index 0000000000..6a2c224609
--- /dev/null
+++ b/services/svc/applicationinsights/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_applicationinsights"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["v1"]
+"v1" = []
diff --git a/services/svc/applicationinsights/src/lib.rs b/services/svc/applicationinsights/src/lib.rs
new file mode 100644
index 0000000000..a798e3294c
--- /dev/null
+++ b/services/svc/applicationinsights/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "v1")]
+mod v1;
+use azure_core::setters;
+#[cfg(feature = "v1")]
+pub use v1::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/applicationinsights/src/v1/mod.rs b/services/svc/applicationinsights/src/v1/mod.rs
new file mode 100644
index 0000000000..88083c7034
--- /dev/null
+++ b/services/svc/applicationinsights/src/v1/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "v1";
diff --git a/services/svc/applicationinsights/src/v1/models.rs b/services/svc/applicationinsights/src/v1/models.rs
new file mode 100644
index 0000000000..1983dc4151
--- /dev/null
+++ b/services/svc/applicationinsights/src/v1/models.rs
@@ -0,0 +1,701 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum MetricId {
+    #[serde(rename = "requests/count")]
+    RequestsCount,
+    #[serde(rename = "requests/duration")]
+    RequestsDuration,
+    #[serde(rename = "requests/failed")]
+    RequestsFailed,
+    #[serde(rename = "users/count")]
+    UsersCount,
+    #[serde(rename = "users/authenticated")]
+    UsersAuthenticated,
+    #[serde(rename = "pageViews/count")]
+    PageViewsCount,
+    #[serde(rename = "pageViews/duration")]
+    PageViewsDuration,
+    #[serde(rename = "client/processingDuration")]
+    ClientProcessingDuration,
+    #[serde(rename = "client/receiveDuration")]
+    ClientReceiveDuration,
+    #[serde(rename = "client/networkDuration")]
+    ClientNetworkDuration,
+    #[serde(rename = "client/sendDuration")]
+    ClientSendDuration,
+    #[serde(rename = "client/totalDuration")]
+    ClientTotalDuration,
+    #[serde(rename = "dependencies/count")]
+    DependenciesCount,
+    #[serde(rename = "dependencies/failed")]
+    DependenciesFailed,
+    #[serde(rename = "dependencies/duration")]
+    DependenciesDuration,
+    #[serde(rename = "exceptions/count")]
+    ExceptionsCount,
+    #[serde(rename = "exceptions/browser")]
+    ExceptionsBrowser,
+    #[serde(rename = "exceptions/server")]
+    ExceptionsServer,
+    #[serde(rename = "sessions/count")]
+    SessionsCount,
+    #[serde(rename = "performanceCounters/requestExecutionTime")]
+    PerformanceCountersRequestExecutionTime,
+    #[serde(rename = "performanceCounters/requestsPerSecond")]
+    PerformanceCountersRequestsPerSecond,
+    #[serde(rename = "performanceCounters/requestsInQueue")]
+    PerformanceCountersRequestsInQueue,
+    #[serde(rename = "performanceCounters/memoryAvailableBytes")]
+    PerformanceCountersMemoryAvailableBytes,
+    #[serde(rename = "performanceCounters/exceptionsPerSecond")]
+    PerformanceCountersExceptionsPerSecond,
+    #[serde(rename = "performanceCounters/processCpuPercentage")]
+    PerformanceCountersProcessCpuPercentage,
+    #[serde(rename = "performanceCounters/processIOBytesPerSecond")]
+    PerformanceCountersProcessIoBytesPerSecond,
+    #[serde(rename = "performanceCounters/processPrivateBytes")]
+    PerformanceCountersProcessPrivateBytes,
+    #[serde(rename = "performanceCounters/processorCpuPercentage")]
+    PerformanceCountersProcessorCpuPercentage,
+    #[serde(rename = "availabilityResults/availabilityPercentage")]
+    AvailabilityResultsAvailabilityPercentage,
+    #[serde(rename = "availabilityResults/duration")]
+    AvailabilityResultsDuration,
+    #[serde(rename = "billing/telemetryCount")]
+    BillingTelemetryCount,
+    #[serde(rename = "customEvents/count")]
+    CustomEventsCount,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsTimespan {}
+pub type MetricsAggregation = Vec<String>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsInterval {}
+pub type MetricsSegment = Vec<String>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsTop {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsOrderBy {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsFilter {}
+pub type MetricsPostBody = Vec<MetricsPostBodySchema>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsPostBodySchema {
+    pub id: String,
+    pub parameters: metrics_post_body_schema::Parameters,
+}
+pub mod metrics_post_body_schema {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Parameters {
+        #[serde(rename = "metricId")]
+        pub metric_id: MetricId,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub timespan: Option<MetricsTimespan>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub aggregation: Option<MetricsAggregation>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub interval: Option<MetricsInterval>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub segment: Option<MetricsSegment>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub top: Option<MetricsTop>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub orderby: Option<MetricsOrderBy>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub filter: Option<MetricsFilter>,
+    }
+}
+pub type MetricsResults = Vec<serde_json::Value>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<MetricsResultInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsResultInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub end: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub interval: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub segments: Vec<MetricsSegmentInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetricsSegmentInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub end: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub segments: Vec<MetricsSegmentInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum EventType {
+    #[serde(rename = "$all")]
+    All,
+    #[serde(rename = "traces")]
+    Traces,
+    #[serde(rename = "customEvents")]
+    CustomEvents,
+    #[serde(rename = "pageViews")]
+    PageViews,
+    #[serde(rename = "browserTimings")]
+    BrowserTimings,
+    #[serde(rename = "requests")]
+    Requests,
+    #[serde(rename = "dependencies")]
+    Dependencies,
+    #[serde(rename = "exceptions")]
+    Exceptions,
+    #[serde(rename = "availabilityResults")]
+    AvailabilityResults,
+    #[serde(rename = "performanceCounters")]
+    PerformanceCounters,
+    #[serde(rename = "customMetrics")]
+    CustomMetrics,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventId {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsTimespan {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsFilter {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsSearch {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsOrderBy {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsSelect {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsSkip {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsTop {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsFormat {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsCount {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsApply {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsResults {
+    #[serde(rename = "@odata.context", default, skip_serializing_if = "Option::is_none")]
+    pub odata_context: Option<String>,
+    #[serde(rename = "@ai.messages", default, skip_serializing_if = "Vec::is_empty")]
+    pub ai_messages: Vec<ErrorInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<EventsResultData>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsResult {
+    #[serde(rename = "@ai.messages", default, skip_serializing_if = "Vec::is_empty")]
+    pub ai_messages: Vec<ErrorInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<EventsResultData>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsResultData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub type_: EventType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(rename = "customDimensions", default, skip_serializing_if = "Option::is_none")]
+    pub custom_dimensions: Option<events_result_data::CustomDimensions>,
+    #[serde(rename = "customMeasurements", default, skip_serializing_if = "Option::is_none")]
+    pub custom_measurements: Option<events_result_data::CustomMeasurements>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub operation: Option<EventsOperationInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub session: Option<EventsSessionInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub user: Option<EventsUserInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cloud: Option<EventsCloudInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ai: Option<EventsAiInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub application: Option<EventsApplicationInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client: Option<EventsClientInfo>,
+}
+pub mod events_result_data {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct CustomDimensions {
+        #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+        pub additional_properties: Option<serde_json::Value>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct CustomMeasurements {
+        #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+        pub additional_properties: Option<serde_json::Value>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsTraceResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsTraceInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "severityLevel", default, skip_serializing_if = "Option::is_none")]
+    pub severity_level: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsCustomEventResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsCustomEventInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsPageViewResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsPageViewInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub duration: Option<String>,
+    #[serde(rename = "performanceBucket", default, skip_serializing_if = "Option::is_none")]
+    pub performance_bucket: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsBrowserTimingResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsBrowserTimingInfo {
+    #[serde(rename = "urlPath", default, skip_serializing_if = "Option::is_none")]
+    pub url_path: Option<String>,
+    #[serde(rename = "urlHost", default, skip_serializing_if = "Option::is_none")]
+    pub url_host: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(rename = "totalDuration", default, skip_serializing_if = "Option::is_none")]
+    pub total_duration: Option<i64>,
+    #[serde(rename = "performanceBucket", default, skip_serializing_if = "Option::is_none")]
+    pub performance_bucket: Option<String>,
+    #[serde(rename = "networkDuration", default, skip_serializing_if = "Option::is_none")]
+    pub network_duration: Option<i64>,
+    #[serde(rename = "sendDuration", default, skip_serializing_if = "Option::is_none")]
+    pub send_duration: Option<i64>,
+    #[serde(rename = "receiveDuration", default, skip_serializing_if = "Option::is_none")]
+    pub receive_duration: Option<i64>,
+    #[serde(rename = "processingDuration", default, skip_serializing_if = "Option::is_none")]
+    pub processing_duration: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsClientPerformanceInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsRequestResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsRequestInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub success: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub duration: Option<f64>,
+    #[serde(rename = "performanceBucket", default, skip_serializing_if = "Option::is_none")]
+    pub performance_bucket: Option<String>,
+    #[serde(rename = "resultCode", default, skip_serializing_if = "Option::is_none")]
+    pub result_code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsDependencyResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsDependencyInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub success: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub duration: Option<i64>,
+    #[serde(rename = "performanceBucket", default, skip_serializing_if = "Option::is_none")]
+    pub performance_bucket: Option<String>,
+    #[serde(rename = "resultCode", default, skip_serializing_if = "Option::is_none")]
+    pub result_code: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsExceptionResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsExceptionInfo {
+    #[serde(rename = "severityLevel", default, skip_serializing_if = "Option::is_none")]
+    pub severity_level: Option<i64>,
+    #[serde(rename = "problemId", default, skip_serializing_if = "Option::is_none")]
+    pub problem_id: Option<String>,
+    #[serde(rename = "handledAt", default, skip_serializing_if = "Option::is_none")]
+    pub handled_at: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub assembly: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub method: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "outerType", default, skip_serializing_if = "Option::is_none")]
+    pub outer_type: Option<String>,
+    #[serde(rename = "outerMethod", default, skip_serializing_if = "Option::is_none")]
+    pub outer_method: Option<String>,
+    #[serde(rename = "outerAssembly", default, skip_serializing_if = "Option::is_none")]
+    pub outer_assembly: Option<String>,
+    #[serde(rename = "outerMessage", default, skip_serializing_if = "Option::is_none")]
+    pub outer_message: Option<String>,
+    #[serde(rename = "innermostType", default, skip_serializing_if = "Option::is_none")]
+    pub innermost_type: Option<String>,
+    #[serde(rename = "innermostMessage", default, skip_serializing_if = "Option::is_none")]
+    pub innermost_message: Option<String>,
+    #[serde(rename = "innermostMethod", default, skip_serializing_if = "Option::is_none")]
+    pub innermost_method: Option<String>,
+    #[serde(rename = "innermostAssembly", default, skip_serializing_if = "Option::is_none")]
+    pub innermost_assembly: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<EventsExceptionDetail>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsExceptionDetail {
+    #[serde(rename = "severityLevel", default, skip_serializing_if = "Option::is_none")]
+    pub severity_level: Option<String>,
+    #[serde(rename = "outerId", default, skip_serializing_if = "Option::is_none")]
+    pub outer_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "parsedStack", default, skip_serializing_if = "Vec::is_empty")]
+    pub parsed_stack: Vec<EventsExceptionDetailsParsedStack>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsExceptionDetailsParsedStack {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub assembly: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub method: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub line: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsAvailabilityResultResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsAvailabilityResultInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub success: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub duration: Option<i64>,
+    #[serde(rename = "performanceBucket", default, skip_serializing_if = "Option::is_none")]
+    pub performance_bucket: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsPerformanceCounterResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsPerformanceCounterInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub category: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub counter: Option<String>,
+    #[serde(rename = "instanceName", default, skip_serializing_if = "Option::is_none")]
+    pub instance_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub instance: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsCustomMetricResult {
+    #[serde(flatten)]
+    pub events_result_data: EventsResultData,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsCustomMetricInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<f64>,
+    #[serde(rename = "valueSum", default, skip_serializing_if = "Option::is_none")]
+    pub value_sum: Option<f64>,
+    #[serde(rename = "valueCount", default, skip_serializing_if = "Option::is_none")]
+    pub value_count: Option<i32>,
+    #[serde(rename = "valueMin", default, skip_serializing_if = "Option::is_none")]
+    pub value_min: Option<f64>,
+    #[serde(rename = "valueMax", default, skip_serializing_if = "Option::is_none")]
+    pub value_max: Option<f64>,
+    #[serde(rename = "valueStdDev", default, skip_serializing_if = "Option::is_none")]
+    pub value_std_dev: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsOperationInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "parentId", default, skip_serializing_if = "Option::is_none")]
+    pub parent_id: Option<String>,
+    #[serde(rename = "syntheticSource", default, skip_serializing_if = "Option::is_none")]
+    pub synthetic_source: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsSessionInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsUserInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
+    pub account_id: Option<String>,
+    #[serde(rename = "authenticatedId", default, skip_serializing_if = "Option::is_none")]
+    pub authenticated_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsCloudInfo {
+    #[serde(rename = "roleName", default, skip_serializing_if = "Option::is_none")]
+    pub role_name: Option<String>,
+    #[serde(rename = "roleInstance", default, skip_serializing_if = "Option::is_none")]
+    pub role_instance: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsAiInfo {
+    #[serde(rename = "iKey", default, skip_serializing_if = "Option::is_none")]
+    pub i_key: Option<String>,
+    #[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
+    pub app_name: Option<String>,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "sdkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub sdk_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsApplicationInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventsClientInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub os: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub browser: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ip: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub city: Option<String>,
+    #[serde(rename = "stateOrProvince", default, skip_serializing_if = "Option::is_none")]
+    pub state_or_province: Option<String>,
+    #[serde(rename = "countryOrRegion", default, skip_serializing_if = "Option::is_none")]
+    pub country_or_region: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryParam {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryTimespan {}
+pub type ApplicationsParam = Vec<String>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryBody {
+    pub query: QueryParam,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timespan: Option<QueryTimespan>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub applications: Option<ApplicationsParam>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryResults {
+    pub tables: Vec<Table>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Table {
+    pub name: String,
+    pub columns: Vec<Column>,
+    pub rows: Vec<Vec<String>>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Column {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataResults {
+    #[serde(rename = "tableGroups", default, skip_serializing_if = "Vec::is_empty")]
+    pub table_groups: Vec<MetadataTableGroup>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tables: Vec<MetadataTable>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub functions: Vec<MetadataFunction>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub applications: Vec<MetadataApplication>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataTableGroup {
+    pub id: String,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tables: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataTable {
+    pub id: String,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "timespanColumn", default, skip_serializing_if = "Option::is_none")]
+    pub timespan_column: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataFunction {
+    pub id: String,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub body: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataApplication {
+    pub id: String,
+    #[serde(rename = "resourceId")]
+    pub resource_id: String,
+    pub name: String,
+    pub region: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tables: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub functions: Vec<String>,
+    #[serde(rename = "tableGroups", default, skip_serializing_if = "Vec::is_empty")]
+    pub table_groups: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorDetail {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<String>,
+    #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+    pub additional_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorInfo {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub innererror: Box<Option<ErrorInfo>>,
+    #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+    pub additional_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    pub error: ErrorInfo,
+}
diff --git a/services/svc/applicationinsights/src/v1/operations.rs b/services/svc/applicationinsights/src/v1/operations.rs
new file mode 100644
index 0000000000..78a5fc06f2
--- /dev/null
+++ b/services/svc/applicationinsights/src/v1/operations.rs
@@ -0,0 +1,721 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod metrics {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        app_id: &str,
+        metric_id: &str,
+        timespan: Option<&str>,
+        interval: Option<&str>,
+        aggregation: &Vec<&str>,
+        segment: &Vec<&str>,
+        top: Option<i32>,
+        orderby: Option<&str>,
+        filter: Option<&str>,
+    ) -> std::result::Result<MetricsResult, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/metrics/{}", operation_config.base_path(), app_id, metric_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timespan) = timespan {
+            url.query_pairs_mut().append_pair("timespan", timespan);
+        }
+        if let Some(interval) = interval {
+            url.query_pairs_mut().append_pair("interval", interval);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("top", top.to_string().as_str());
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("orderby", orderby);
+        }
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("filter", filter);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetricsResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_multiple(
+        operation_config: &crate::OperationConfig,
+        app_id: &str,
+        body: &MetricsPostBody,
+    ) -> std::result::Result<MetricsResults, get_multiple::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/metrics", operation_config.base_path(), app_id);
+        let mut url = url::Url::parse(url_str).map_err(get_multiple::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_multiple::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(body).map_err(get_multiple::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_multiple::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_multiple::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetricsResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_multiple::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_multiple::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_multiple::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_multiple {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        app_id: &str,
+    ) -> std::result::Result<serde_json::Value, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/metrics/metadata", operation_config.base_path(), app_id);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: serde_json::Value =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod events {
+    use crate::models::*;
+    pub async fn get_by_type(
+        operation_config: &crate::OperationConfig,
+        app_id: &str,
+        event_type: &str,
+        timespan: Option<&str>,
+        filter: Option<&str>,
+        search: Option<&str>,
+        orderby: Option<&str>,
+        select: Option<&str>,
+        skip: Option<i32>,
+        top: Option<i32>,
+        format: Option<&str>,
+        count: Option<bool>,
+        apply: Option<&str>,
+    ) -> std::result::Result<EventsResults, get_by_type::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/events/{}", operation_config.base_path(), app_id, event_type);
+        let mut url = url::Url::parse(url_str).map_err(get_by_type::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_by_type::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timespan) = timespan {
+            url.query_pairs_mut().append_pair("timespan", timespan);
+        }
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(search) = search {
+            url.query_pairs_mut().append_pair("$search", search);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        if let Some(apply) = apply {
+            url.query_pairs_mut().append_pair("$apply", apply);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_by_type::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_by_type::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: EventsResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_by_type::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_by_type::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_by_type::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_by_type {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        app_id: &str,
+        event_type: &str,
+        timespan: Option<&str>,
+        event_id: &str,
+    ) -> std::result::Result<EventsResults, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/apps/{}/events/{}/{}",
+            operation_config.base_path(),
+            app_id,
+            event_type,
+            event_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timespan) = timespan {
+            url.query_pairs_mut().append_pair("timespan", timespan);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: EventsResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_odata_metadata(
+        operation_config: &crate::OperationConfig,
+        app_id: &str,
+    ) -> std::result::Result<serde_json::Value, get_odata_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/events/$metadata", operation_config.base_path(), app_id);
+        let mut url = url::Url::parse(url_str).map_err(get_odata_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_odata_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_odata_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_odata_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: serde_json::Value = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_odata_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_odata_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_odata_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_odata_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod query {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        app_id: &str,
+        query: &str,
+        timespan: Option<&str>,
+    ) -> std::result::Result<QueryResults, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/query", operation_config.base_path(), app_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("query", query);
+        if let Some(timespan) = timespan {
+            url.query_pairs_mut().append_pair("timespan", timespan);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute(
+        operation_config: &crate::OperationConfig,
+        app_id: &str,
+        body: &QueryBody,
+    ) -> std::result::Result<QueryResults, execute::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/query", operation_config.base_path(), app_id);
+        let mut url = url::Url::parse(url_str).map_err(execute::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(body).map_err(execute::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod metadata {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, app_id: &str) -> std::result::Result<MetadataResults, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/metadata", operation_config.base_path(), app_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetadataResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn post(operation_config: &crate::OperationConfig, app_id: &str) -> std::result::Result<MetadataResults, post::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apps/{}/metadata", operation_config.base_path(), app_id);
+        let mut url = url::Url::parse(url_str).map_err(post::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(post::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(post::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(post::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetadataResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| post::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| post::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(post::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod post {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/attestation/Cargo.toml b/services/svc/attestation/Cargo.toml
new file mode 100644
index 0000000000..35028ae055
--- /dev/null
+++ b/services/svc/attestation/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_attestation"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2020-10-01"]
+"package-2020-10-01" = []
diff --git a/services/svc/attestation/src/lib.rs b/services/svc/attestation/src/lib.rs
new file mode 100644
index 0000000000..8c7b999978
--- /dev/null
+++ b/services/svc/attestation/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2020-10-01")]
+mod package_2020_10_01;
+use azure_core::setters;
+#[cfg(feature = "package-2020-10-01")]
+pub use package_2020_10_01::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/attestation/src/package_2020_10_01/mod.rs b/services/svc/attestation/src/package_2020_10_01/mod.rs
new file mode 100644
index 0000000000..1ef716874c
--- /dev/null
+++ b/services/svc/attestation/src/package_2020_10_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-10-01";
diff --git a/services/svc/attestation/src/package_2020_10_01/models.rs b/services/svc/attestation/src/package_2020_10_01/models.rs
new file mode 100644
index 0000000000..98c0b98e85
--- /dev/null
+++ b/services/svc/attestation/src/package_2020_10_01/models.rs
@@ -0,0 +1,251 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<CloudErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudErrorBody {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonWebToken {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestationCertificateManagementBody {
+    #[serde(rename = "policyCertificate", default, skip_serializing_if = "Option::is_none")]
+    pub policy_certificate: Option<JsonWebKey>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyCertificatesResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<JsonWebToken>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyCertificatesResult {
+    #[serde(rename = "x-ms-policy-certificates", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policy_certificates: Option<JsonWebKeySet>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyCertificatesModifyResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<JsonWebToken>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyCertificatesModificationResult {
+    #[serde(rename = "x-ms-certificate-thumbprint", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_certificate_thumbprint: Option<String>,
+    #[serde(rename = "x-ms-policycertificates-result", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policycertificates_result: Option<policy_certificates_modification_result::XMsPolicycertificatesResult>,
+}
+pub mod policy_certificates_modification_result {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum XMsPolicycertificatesResult {
+        IsPresent,
+        IsAbsent,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoredAttestationPolicy {
+    #[serde(rename = "AttestationPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub attestation_policy: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<JsonWebToken>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyResult {
+    #[serde(rename = "x-ms-policy-result", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policy_result: Option<policy_result::XMsPolicyResult>,
+    #[serde(rename = "x-ms-policy-token-hash", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policy_token_hash: Option<String>,
+    #[serde(rename = "x-ms-policy-signer", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policy_signer: Option<JsonWebKey>,
+    #[serde(rename = "x-ms-policy", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policy: Option<JsonWebToken>,
+}
+pub mod policy_result {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum XMsPolicyResult {
+        Updated,
+        Removed,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub jti: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub iss: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub iat: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cnf: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub nonce: Option<String>,
+    #[serde(rename = "x-ms-ver", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_ver: Option<String>,
+    #[serde(rename = "x-ms-runtime", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_runtime: Option<serde_json::Value>,
+    #[serde(rename = "x-ms-inittime", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_inittime: Option<serde_json::Value>,
+    #[serde(rename = "x-ms-policy", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policy: Option<serde_json::Value>,
+    #[serde(rename = "x-ms-attestation-type", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_attestation_type: Option<String>,
+    #[serde(rename = "x-ms-policy-signer", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policy_signer: Option<JsonWebKey>,
+    #[serde(rename = "x-ms-policy-hash", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_policy_hash: Option<String>,
+    #[serde(rename = "x-ms-sgx-is-debuggable", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_sgx_is_debuggable: Option<bool>,
+    #[serde(rename = "x-ms-sgx-product-id", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_sgx_product_id: Option<f64>,
+    #[serde(rename = "x-ms-sgx-mrenclave", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_sgx_mrenclave: Option<String>,
+    #[serde(rename = "x-ms-sgx-mrsigner", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_sgx_mrsigner: Option<String>,
+    #[serde(rename = "x-ms-sgx-svn", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_sgx_svn: Option<f64>,
+    #[serde(rename = "x-ms-sgx-ehd", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_sgx_ehd: Option<String>,
+    #[serde(rename = "x-ms-sgx-collateral", default, skip_serializing_if = "Option::is_none")]
+    pub x_ms_sgx_collateral: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ver: Option<String>,
+    #[serde(rename = "is-debuggable", default, skip_serializing_if = "Option::is_none")]
+    pub is_debuggable: Option<bool>,
+    #[serde(rename = "maa-attestationcollateral", default, skip_serializing_if = "Option::is_none")]
+    pub maa_attestationcollateral: Option<serde_json::Value>,
+    #[serde(rename = "aas-ehd", default, skip_serializing_if = "Option::is_none")]
+    pub aas_ehd: Option<String>,
+    #[serde(rename = "maa-ehd", default, skip_serializing_if = "Option::is_none")]
+    pub maa_ehd: Option<String>,
+    #[serde(rename = "product-id", default, skip_serializing_if = "Option::is_none")]
+    pub product_id: Option<f64>,
+    #[serde(rename = "sgx-mrenclave", default, skip_serializing_if = "Option::is_none")]
+    pub sgx_mrenclave: Option<String>,
+    #[serde(rename = "sgx-mrsigner", default, skip_serializing_if = "Option::is_none")]
+    pub sgx_mrsigner: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub svn: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tee: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub policy_signer: Option<JsonWebKey>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub policy_hash: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub rp_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestationResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<JsonWebToken>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DataType {
+    Binary,
+    #[serde(rename = "JSON")]
+    Json,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RuntimeData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+    #[serde(rename = "dataType", default, skip_serializing_if = "Option::is_none")]
+    pub data_type: Option<DataType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InitTimeData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+    #[serde(rename = "dataType", default, skip_serializing_if = "Option::is_none")]
+    pub data_type: Option<DataType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestSgxEnclaveRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub quote: Option<String>,
+    #[serde(rename = "runtimeData", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_data: Option<RuntimeData>,
+    #[serde(rename = "initTimeData", default, skip_serializing_if = "Option::is_none")]
+    pub init_time_data: Option<InitTimeData>,
+    #[serde(rename = "draftPolicyForAttestation", default, skip_serializing_if = "Option::is_none")]
+    pub draft_policy_for_attestation: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestOpenEnclaveRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub report: Option<String>,
+    #[serde(rename = "runtimeData", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_data: Option<RuntimeData>,
+    #[serde(rename = "initTimeData", default, skip_serializing_if = "Option::is_none")]
+    pub init_time_data: Option<InitTimeData>,
+    #[serde(rename = "draftPolicyForAttestation", default, skip_serializing_if = "Option::is_none")]
+    pub draft_policy_for_attestation: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TpmAttestationRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TpmAttestationResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonWebKeySet {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub keys: Vec<JsonWebKey>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonWebKey {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub alg: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub crv: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub d: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dq: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub e: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub k: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kid: Option<String>,
+    pub kty: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub n: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub p: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub q: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub qi: Option<String>,
+    #[serde(rename = "use", default, skip_serializing_if = "Option::is_none")]
+    pub use_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub x: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub x5c: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub y: Option<String>,
+}
diff --git a/services/svc/attestation/src/package_2020_10_01/operations.rs b/services/svc/attestation/src/package_2020_10_01/operations.rs
new file mode 100644
index 0000000000..d2aebc6eb0
--- /dev/null
+++ b/services/svc/attestation/src/package_2020_10_01/operations.rs
@@ -0,0 +1,699 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod policy {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, attestation_type: &str) -> std::result::Result<PolicyResponse, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/policies/{}", operation_config.base_path(), attestation_type);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PolicyResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn set(
+        operation_config: &crate::OperationConfig,
+        attestation_type: &str,
+        new_attestation_policy: &JsonWebToken,
+    ) -> std::result::Result<PolicyResponse, set::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/policies/{}", operation_config.base_path(), attestation_type);
+        let mut url = url::Url::parse(url_str).map_err(set::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(set::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(new_attestation_policy).map_err(set::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(set::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(set::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PolicyResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| set::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| set::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(set::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod set {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn reset(
+        operation_config: &crate::OperationConfig,
+        attestation_type: &str,
+        policy_jws: &JsonWebToken,
+    ) -> std::result::Result<PolicyResponse, reset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/policies/{}:reset", operation_config.base_path(), attestation_type);
+        let mut url = url::Url::parse(url_str).map_err(reset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(reset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(policy_jws).map_err(reset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(reset::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(reset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PolicyResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| reset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| reset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(reset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod reset {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod policy_certificates {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig) -> std::result::Result<PolicyCertificatesResponse, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/certificates", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PolicyCertificatesResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add(
+        operation_config: &crate::OperationConfig,
+        policy_certificate_to_add: &JsonWebToken,
+    ) -> std::result::Result<PolicyCertificatesModifyResponse, add::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/certificates:add", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(add::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(policy_certificate_to_add).map_err(add::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(add::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PolicyCertificatesModifyResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| add::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(
+        operation_config: &crate::OperationConfig,
+        policy_certificate_to_remove: &JsonWebToken,
+    ) -> std::result::Result<PolicyCertificatesModifyResponse, remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/certificates:remove", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(policy_certificate_to_remove).map_err(remove::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PolicyCertificatesModifyResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| remove::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| remove::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(remove::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attestation {
+    use crate::models::*;
+    pub async fn attest_open_enclave(
+        operation_config: &crate::OperationConfig,
+        request: &AttestOpenEnclaveRequest,
+    ) -> std::result::Result<AttestationResponse, attest_open_enclave::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attest/OpenEnclave", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(attest_open_enclave::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(attest_open_enclave::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(attest_open_enclave::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(attest_open_enclave::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(attest_open_enclave::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestationResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| attest_open_enclave::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| attest_open_enclave::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(attest_open_enclave::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod attest_open_enclave {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn attest_sgx_enclave(
+        operation_config: &crate::OperationConfig,
+        request: &AttestSgxEnclaveRequest,
+    ) -> std::result::Result<AttestationResponse, attest_sgx_enclave::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attest/SgxEnclave", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(attest_sgx_enclave::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(attest_sgx_enclave::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(attest_sgx_enclave::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(attest_sgx_enclave::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(attest_sgx_enclave::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestationResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| attest_sgx_enclave::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| attest_sgx_enclave::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(attest_sgx_enclave::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod attest_sgx_enclave {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn attest_tpm(
+        operation_config: &crate::OperationConfig,
+        request: &TpmAttestationRequest,
+    ) -> std::result::Result<TpmAttestationResponse, attest_tpm::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attest/Tpm", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(attest_tpm::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(attest_tpm::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(attest_tpm::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(attest_tpm::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(attest_tpm::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TpmAttestationResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| attest_tpm::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| attest_tpm::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(attest_tpm::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod attest_tpm {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod signing_certificates {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig) -> std::result::Result<JsonWebKeySet, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/certs", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JsonWebKeySet =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod metadata_configuration {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig) -> std::result::Result<serde_json::Value, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/.well-known/openid-configuration", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: serde_json::Value =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/confidentialledger/Cargo.toml b/services/svc/confidentialledger/Cargo.toml
new file mode 100644
index 0000000000..8aa38ee0e4
--- /dev/null
+++ b/services/svc/confidentialledger/Cargo.toml
@@ -0,0 +1,24 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_confidentialledger"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-0.1-preview-ledger"]
+"package-0.1-preview-ledger" = []
+"package-0.1-preview-identity" = []
diff --git a/services/svc/confidentialledger/src/lib.rs b/services/svc/confidentialledger/src/lib.rs
new file mode 100644
index 0000000000..4718ca25ff
--- /dev/null
+++ b/services/svc/confidentialledger/src/lib.rs
@@ -0,0 +1,65 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-0.1-preview-ledger")]
+mod package_0_1_preview_ledger;
+#[cfg(feature = "package-0.1-preview-ledger")]
+pub use package_0_1_preview_ledger::{models, operations, API_VERSION};
+#[cfg(feature = "package-0.1-preview-identity")]
+mod package_0_1_preview_identity;
+use azure_core::setters;
+#[cfg(feature = "package-0.1-preview-identity")]
+pub use package_0_1_preview_identity::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/confidentialledger/src/package_0_1_preview_identity/mod.rs b/services/svc/confidentialledger/src/package_0_1_preview_identity/mod.rs
new file mode 100644
index 0000000000..d7d76b9db9
--- /dev/null
+++ b/services/svc/confidentialledger/src/package_0_1_preview_identity/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "0.1-preview";
diff --git a/services/svc/confidentialledger/src/package_0_1_preview_identity/models.rs b/services/svc/confidentialledger/src/package_0_1_preview_identity/models.rs
new file mode 100644
index 0000000000..2f7e61faa4
--- /dev/null
+++ b/services/svc/confidentialledger/src/package_0_1_preview_identity/models.rs
@@ -0,0 +1,25 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LedgerIdentityInformation {
+    #[serde(rename = "ledgerId", default, skip_serializing_if = "Option::is_none")]
+    pub ledger_id: Option<String>,
+    #[serde(rename = "ledgerTlsCertificate")]
+    pub ledger_tls_certificate: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConfidentialLedgerError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ConfidentialLedgerErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConfidentialLedgerErrorBody {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub innererror: Box<Option<ConfidentialLedgerErrorBody>>,
+}
diff --git a/services/svc/confidentialledger/src/package_0_1_preview_identity/operations.rs b/services/svc/confidentialledger/src/package_0_1_preview_identity/operations.rs
new file mode 100644
index 0000000000..46cee8b106
--- /dev/null
+++ b/services/svc/confidentialledger/src/package_0_1_preview_identity/operations.rs
@@ -0,0 +1,73 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod confidential_ledger_identity_service {
+    use crate::models::*;
+    pub async fn get_ledger_identity(
+        operation_config: &crate::OperationConfig,
+        ledger_id: &str,
+    ) -> std::result::Result<LedgerIdentityInformation, get_ledger_identity::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/ledgerIdentity/{}", operation_config.base_path(), ledger_id);
+        let mut url = url::Url::parse(url_str).map_err(get_ledger_identity::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_ledger_identity::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_ledger_identity::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_ledger_identity::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LedgerIdentityInformation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_ledger_identity::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_ledger_identity::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_ledger_identity::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_ledger_identity {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/confidentialledger/src/package_0_1_preview_ledger/mod.rs b/services/svc/confidentialledger/src/package_0_1_preview_ledger/mod.rs
new file mode 100644
index 0000000000..d7d76b9db9
--- /dev/null
+++ b/services/svc/confidentialledger/src/package_0_1_preview_ledger/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "0.1-preview";
diff --git a/services/svc/confidentialledger/src/package_0_1_preview_ledger/models.rs b/services/svc/confidentialledger/src/package_0_1_preview_ledger/models.rs
new file mode 100644
index 0000000000..390a43d08e
--- /dev/null
+++ b/services/svc/confidentialledger/src/package_0_1_preview_ledger/models.rs
@@ -0,0 +1,147 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConfidentialLedgerEnclaves {
+    #[serde(rename = "currentNodeId")]
+    pub current_node_id: EntityId,
+    #[serde(rename = "enclaveQuotes")]
+    pub enclave_quotes: EnclaveQuotes,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Consortium {
+    pub members: Vec<ConsortiumMember>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConsortiumMember {
+    pub certificate: String,
+    pub id: EntityId,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Constitution {
+    pub digest: String,
+    pub script: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EnclaveQuote {
+    #[serde(rename = "nodeId")]
+    pub node_id: EntityId,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mrenclave: Option<String>,
+    #[serde(rename = "quoteVersion")]
+    pub quote_version: String,
+    pub raw: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EnclaveQuotes {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EntityId {}
+pub type LedgerEntries = Vec<LedgerEntry>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LedgerEntry {
+    pub contents: String,
+    #[serde(rename = "subLedgerId", default, skip_serializing_if = "Option::is_none")]
+    pub sub_ledger_id: Option<SubLedgerId>,
+    #[serde(rename = "transactionId", default, skip_serializing_if = "Option::is_none")]
+    pub transaction_id: Option<TransactionId>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LedgerQueryResult {
+    pub state: LedgerQueryState,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub entry: Option<LedgerEntry>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum LedgerQueryState {
+    Loading,
+    Ready,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LedgerUser {
+    #[serde(rename = "assignedRole")]
+    pub assigned_role: LedgerUserRole,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<UserId>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum LedgerUserRole {
+    Administrator,
+    Contributor,
+    Reader,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LedgerWriteResult {
+    #[serde(rename = "subLedgerId")]
+    pub sub_ledger_id: SubLedgerId,
+}
+pub type MerkleProof = Vec<MerkleProofElement>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MerkleProofElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub left: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub right: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PagedLedgerEntries {
+    pub state: LedgerQueryState,
+    #[serde(rename = "@nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    pub entries: LedgerEntries,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ReceiptContents {
+    pub leaf: String,
+    #[serde(rename = "nodeId")]
+    pub node_id: EntityId,
+    pub proof: MerkleProof,
+    pub root: String,
+    pub signature: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignment {
+    #[serde(rename = "roleName")]
+    pub role_name: LedgerUserRole,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubLedgerId {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TransactionId {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TransactionReceipt {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub receipt: Option<ReceiptContents>,
+    pub state: LedgerQueryState,
+    #[serde(rename = "transactionId")]
+    pub transaction_id: TransactionId,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TransactionState {
+    Committed,
+    Pending,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TransactionStatus {
+    pub state: TransactionState,
+    #[serde(rename = "transactionId")]
+    pub transaction_id: TransactionId,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserId {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConfidentialLedgerError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ConfidentialLedgerErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConfidentialLedgerErrorBody {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub innererror: Box<Option<ConfidentialLedgerErrorBody>>,
+}
diff --git a/services/svc/confidentialledger/src/package_0_1_preview_ledger/operations.rs b/services/svc/confidentialledger/src/package_0_1_preview_ledger/operations.rs
new file mode 100644
index 0000000000..c56bf9a49b
--- /dev/null
+++ b/services/svc/confidentialledger/src/package_0_1_preview_ledger/operations.rs
@@ -0,0 +1,807 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod confidential_ledger {
+    use crate::models::*;
+    pub async fn get_constitution(operation_config: &crate::OperationConfig) -> std::result::Result<Constitution, get_constitution::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/governance/constitution", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_constitution::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_constitution::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_constitution::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_constitution::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Constitution = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_constitution::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_constitution::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_constitution::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_constitution {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_consortium_members(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<Consortium, get_consortium_members::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/governance/members", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_consortium_members::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_consortium_members::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_consortium_members::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_consortium_members::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Consortium = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_consortium_members::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_consortium_members::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_consortium_members::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_consortium_members {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_enclave_quotes(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<ConfidentialLedgerEnclaves, get_enclave_quotes::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/enclaveQuotes", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_enclave_quotes::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_enclave_quotes::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_enclave_quotes::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_enclave_quotes::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerEnclaves = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_enclave_quotes::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_enclave_quotes::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_enclave_quotes::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_enclave_quotes {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_ledger_entries(
+        operation_config: &crate::OperationConfig,
+        sub_ledger_id: Option<&str>,
+        from_transaction_id: Option<&str>,
+        to_transaction_id: Option<&str>,
+    ) -> std::result::Result<PagedLedgerEntries, get_ledger_entries::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/transactions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_ledger_entries::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_ledger_entries::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(sub_ledger_id) = sub_ledger_id {
+            url.query_pairs_mut().append_pair("subLedgerId", sub_ledger_id);
+        }
+        if let Some(from_transaction_id) = from_transaction_id {
+            url.query_pairs_mut().append_pair("fromTransactionId", from_transaction_id);
+        }
+        if let Some(to_transaction_id) = to_transaction_id {
+            url.query_pairs_mut().append_pair("toTransactionId", to_transaction_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_ledger_entries::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_ledger_entries::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PagedLedgerEntries = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_ledger_entries::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_ledger_entries::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_ledger_entries::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_ledger_entries {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn post_ledger_entry(
+        operation_config: &crate::OperationConfig,
+        sub_ledger_id: Option<&str>,
+        entry: Option<&LedgerEntry>,
+    ) -> std::result::Result<LedgerWriteResult, post_ledger_entry::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/transactions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(post_ledger_entry::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(post_ledger_entry::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(sub_ledger_id) = sub_ledger_id {
+            url.query_pairs_mut().append_pair("subLedgerId", sub_ledger_id);
+        }
+        let req_body = if let Some(entry) = entry {
+            azure_core::to_json(entry).map_err(post_ledger_entry::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(post_ledger_entry::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(post_ledger_entry::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LedgerWriteResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| post_ledger_entry::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| post_ledger_entry::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(post_ledger_entry::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod post_ledger_entry {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_ledger_entry(
+        operation_config: &crate::OperationConfig,
+        sub_ledger_id: Option<&str>,
+        transaction_id: &str,
+    ) -> std::result::Result<LedgerQueryResult, get_ledger_entry::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/transactions/{}", operation_config.base_path(), transaction_id);
+        let mut url = url::Url::parse(url_str).map_err(get_ledger_entry::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_ledger_entry::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(sub_ledger_id) = sub_ledger_id {
+            url.query_pairs_mut().append_pair("subLedgerId", sub_ledger_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_ledger_entry::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_ledger_entry::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LedgerQueryResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_ledger_entry::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_ledger_entry::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_ledger_entry::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_ledger_entry {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_receipt(
+        operation_config: &crate::OperationConfig,
+        transaction_id: &str,
+    ) -> std::result::Result<TransactionReceipt, get_receipt::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/transactions/{}/receipt", operation_config.base_path(), transaction_id);
+        let mut url = url::Url::parse(url_str).map_err(get_receipt::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_receipt::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_receipt::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_receipt::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TransactionReceipt =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_receipt::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_receipt::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_receipt::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_receipt {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_transaction_status(
+        operation_config: &crate::OperationConfig,
+        transaction_id: &str,
+    ) -> std::result::Result<TransactionStatus, get_transaction_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/transactions/{}/status", operation_config.base_path(), transaction_id);
+        let mut url = url::Url::parse(url_str).map_err(get_transaction_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_transaction_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_transaction_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_transaction_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TransactionStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_transaction_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_transaction_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_transaction_status::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_transaction_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_current_ledger_entry(
+        operation_config: &crate::OperationConfig,
+        sub_ledger_id: Option<&str>,
+    ) -> std::result::Result<LedgerEntry, get_current_ledger_entry::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/transactions/current", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_current_ledger_entry::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_current_ledger_entry::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(sub_ledger_id) = sub_ledger_id {
+            url.query_pairs_mut().append_pair("subLedgerId", sub_ledger_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_current_ledger_entry::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_current_ledger_entry::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LedgerEntry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_current_ledger_entry::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_current_ledger_entry::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_current_ledger_entry::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_current_ledger_entry {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_user(operation_config: &crate::OperationConfig, user_id: &str) -> std::result::Result<LedgerUser, get_user::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(get_user::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_user::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_user::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_user::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LedgerUser =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_user::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_user::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_user::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_user {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_user(
+        operation_config: &crate::OperationConfig,
+        user_id: &str,
+        user_details: &LedgerUser,
+    ) -> std::result::Result<LedgerUser, create_or_update_user::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_user::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_user::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(user_details).map_err(create_or_update_user::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_user::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_user::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LedgerUser = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_user::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_user::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_user::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_user {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_user(operation_config: &crate::OperationConfig, user_id: &str) -> std::result::Result<(), delete_user::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/app/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(delete_user::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_user::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_user::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_user::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConfidentialLedgerError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_user::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_user::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_user {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ConfidentialLedgerError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/containerregistry/Cargo.toml b/services/svc/containerregistry/Cargo.toml
new file mode 100644
index 0000000000..3c3441fd3d
--- /dev/null
+++ b/services/svc/containerregistry/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_containerregistry"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2018-08"]
+"package-2018-08" = []
diff --git a/services/svc/containerregistry/src/lib.rs b/services/svc/containerregistry/src/lib.rs
new file mode 100644
index 0000000000..afb45a1edd
--- /dev/null
+++ b/services/svc/containerregistry/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2018-08")]
+mod package_2018_08;
+use azure_core::setters;
+#[cfg(feature = "package-2018-08")]
+pub use package_2018_08::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/containerregistry/src/package_2018_08/mod.rs b/services/svc/containerregistry/src/package_2018_08/mod.rs
new file mode 100644
index 0000000000..ab4eb2e01c
--- /dev/null
+++ b/services/svc/containerregistry/src/package_2018_08/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2018-08-10";
diff --git a/services/svc/containerregistry/src/package_2018_08/models.rs b/services/svc/containerregistry/src/package_2018_08/models.rs
new file mode 100644
index 0000000000..221cf3c850
--- /dev/null
+++ b/services/svc/containerregistry/src/package_2018_08/models.rs
@@ -0,0 +1,236 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RepositoryAttributes {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub registry: Option<String>,
+    #[serde(rename = "imageName", default, skip_serializing_if = "Option::is_none")]
+    pub image_name: Option<String>,
+    #[serde(rename = "createdTime", default, skip_serializing_if = "Option::is_none")]
+    pub created_time: Option<String>,
+    #[serde(rename = "lastUpdateTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_update_time: Option<String>,
+    #[serde(rename = "manifestCount", default, skip_serializing_if = "Option::is_none")]
+    pub manifest_count: Option<f64>,
+    #[serde(rename = "tagCount", default, skip_serializing_if = "Option::is_none")]
+    pub tag_count: Option<f64>,
+    #[serde(rename = "changeableAttributes", default, skip_serializing_if = "Option::is_none")]
+    pub changeable_attributes: Option<ChangeableAttributes>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcrRepositoryTags {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub registry: Option<String>,
+    #[serde(rename = "imageName", default, skip_serializing_if = "Option::is_none")]
+    pub image_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<AcrTagAttributesBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcrTagAttributes {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub registry: Option<String>,
+    #[serde(rename = "imageName", default, skip_serializing_if = "Option::is_none")]
+    pub image_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tag: Option<AcrTagAttributesBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagAttributes {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub registry: Option<String>,
+    #[serde(rename = "imageName", default, skip_serializing_if = "Option::is_none")]
+    pub image_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tag: Option<TagAttributesTag>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcrTagAttributesBase {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub digest: Option<String>,
+    #[serde(rename = "createdTime", default, skip_serializing_if = "Option::is_none")]
+    pub created_time: Option<String>,
+    #[serde(rename = "lastUpdateTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_update_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signed: Option<bool>,
+    #[serde(rename = "changeableAttributes", default, skip_serializing_if = "Option::is_none")]
+    pub changeable_attributes: Option<ChangeableAttributes>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcrManifests {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub registry: Option<String>,
+    #[serde(rename = "imageName", default, skip_serializing_if = "Option::is_none")]
+    pub image_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub manifests: Vec<AcrManifestAttributesBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcrManifestAttributes {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub registry: Option<String>,
+    #[serde(rename = "imageName", default, skip_serializing_if = "Option::is_none")]
+    pub image_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub manifest: Option<AcrManifestAttributesBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcrManifestAttributesBase {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub digest: Option<String>,
+    #[serde(rename = "createdTime", default, skip_serializing_if = "Option::is_none")]
+    pub created_time: Option<String>,
+    #[serde(rename = "lastUpdateTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_update_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub architecture: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub os: Option<String>,
+    #[serde(rename = "mediaType", default, skip_serializing_if = "Option::is_none")]
+    pub media_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+    #[serde(rename = "changeableAttributes", default, skip_serializing_if = "Option::is_none")]
+    pub changeable_attributes: Option<ChangeableAttributes>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcrErrors {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub errors: Vec<AcrErrorInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RepositoryTags {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Manifest {
+    #[serde(rename = "schemaVersion", default, skip_serializing_if = "Option::is_none")]
+    pub schema_version: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub architecture: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tag: Option<String>,
+    #[serde(rename = "fsLayers", default, skip_serializing_if = "Vec::is_empty")]
+    pub fs_layers: Vec<ImageLayer>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub history: Vec<ImageHistory>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub signatures: Vec<ImageSignature>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageSignature {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub header: Option<Jwk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub protected: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Jwk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub jwk: Option<JwkHeader>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub alg: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JwkHeader {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub crv: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kid: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kty: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub x: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub y: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageHistory {
+    #[serde(rename = "v1Compatibility", default, skip_serializing_if = "Option::is_none")]
+    pub v1_compatibility: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Repositories {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub repositories: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeletedRepository {
+    #[serde(rename = "manifestsDeleted", default, skip_serializing_if = "Vec::is_empty")]
+    pub manifests_deleted: Vec<String>,
+    #[serde(rename = "tagsDeleted", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_deleted: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcrErrorInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub detail: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageLayer {
+    #[serde(rename = "blobSum", default, skip_serializing_if = "Option::is_none")]
+    pub blob_sum: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ChangeableAttributes {
+    #[serde(rename = "deleteEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub delete_enabled: Option<bool>,
+    #[serde(rename = "writeEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_enabled: Option<bool>,
+    #[serde(rename = "listEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub list_enabled: Option<bool>,
+    #[serde(rename = "readEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub read_enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagAttributesTag {
+    #[serde(rename = "signatureRecord", default, skip_serializing_if = "Option::is_none")]
+    pub signature_record: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManifestAttributesManifestReferences {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub digest: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub architecture: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub os: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManifestAttributesManifest {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub references: Vec<ManifestAttributesManifestReferences>,
+    #[serde(rename = "quarantineTag", default, skip_serializing_if = "Option::is_none")]
+    pub quarantine_tag: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManifestChangeableAttributes {
+    #[serde(rename = "deleteEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub delete_enabled: Option<bool>,
+    #[serde(rename = "writeEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_enabled: Option<bool>,
+    #[serde(rename = "listEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub list_enabled: Option<bool>,
+    #[serde(rename = "readEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub read_enabled: Option<bool>,
+    #[serde(rename = "quarantineState", default, skip_serializing_if = "Option::is_none")]
+    pub quarantine_state: Option<String>,
+    #[serde(rename = "quarantineDetails", default, skip_serializing_if = "Option::is_none")]
+    pub quarantine_details: Option<String>,
+}
diff --git a/services/svc/containerregistry/src/package_2018_08/operations.rs b/services/svc/containerregistry/src/package_2018_08/operations.rs
new file mode 100644
index 0000000000..ee4b43776f
--- /dev/null
+++ b/services/svc/containerregistry/src/package_2018_08/operations.rs
@@ -0,0 +1,1054 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub async fn get_docker_registry_v2_support(
+    operation_config: &crate::OperationConfig,
+) -> std::result::Result<(), get_docker_registry_v2_support::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/v2/", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_docker_registry_v2_support::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_docker_registry_v2_support::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(get_docker_registry_v2_support::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_docker_registry_v2_support::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => Ok(()),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_docker_registry_v2_support::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_docker_registry_v2_support::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_docker_registry_v2_support {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_tag_list(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+) -> std::result::Result<RepositoryTags, get_tag_list::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/v2/{}/tags/list", operation_config.base_path(), name);
+    let mut url = url::Url::parse(url_str).map_err(get_tag_list::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_tag_list::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_tag_list::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_tag_list::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: RepositoryTags =
+                serde_json::from_slice(rsp_body).map_err(|source| get_tag_list::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::NOT_FOUND => Err(get_tag_list::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors =
+                serde_json::from_slice(rsp_body).map_err(|source| get_tag_list::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_tag_list::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_tag_list {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_manifest(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    reference: &str,
+) -> std::result::Result<Manifest, get_manifest::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/v2/{}/manifests/{}", operation_config.base_path(), name, reference);
+    let mut url = url::Url::parse(url_str).map_err(get_manifest::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_manifest::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_manifest::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_manifest::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: Manifest =
+                serde_json::from_slice(rsp_body).map_err(|source| get_manifest::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::NOT_FOUND => Err(get_manifest::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors =
+                serde_json::from_slice(rsp_body).map_err(|source| get_manifest::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_manifest::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_manifest {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_repositories(
+    operation_config: &crate::OperationConfig,
+    last: Option<&str>,
+    n: Option<&str>,
+) -> std::result::Result<Repositories, get_repositories::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/v2/_catalog", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_repositories::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_repositories::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    if let Some(last) = last {
+        url.query_pairs_mut().append_pair("last", last);
+    }
+    if let Some(n) = n {
+        url.query_pairs_mut().append_pair("n", n);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_repositories::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_repositories::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: Repositories =
+                serde_json::from_slice(rsp_body).map_err(|source| get_repositories::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors =
+                serde_json::from_slice(rsp_body).map_err(|source| get_repositories::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_repositories::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_repositories {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_acr_repositories(
+    operation_config: &crate::OperationConfig,
+    last: Option<&str>,
+    n: Option<&str>,
+) -> std::result::Result<Repositories, get_acr_repositories::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/_catalog", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_acr_repositories::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_acr_repositories::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    if let Some(last) = last {
+        url.query_pairs_mut().append_pair("last", last);
+    }
+    if let Some(n) = n {
+        url.query_pairs_mut().append_pair("n", n);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_acr_repositories::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_acr_repositories::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: Repositories = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_acr_repositories::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_acr_repositories::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_acr_repositories::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_acr_repositories {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_acr_repository_attributes(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+) -> std::result::Result<RepositoryAttributes, get_acr_repository_attributes::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}", operation_config.base_path(), name);
+    let mut url = url::Url::parse(url_str).map_err(get_acr_repository_attributes::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_acr_repository_attributes::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(get_acr_repository_attributes::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_acr_repository_attributes::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: RepositoryAttributes = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_acr_repository_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::NOT_FOUND => Err(get_acr_repository_attributes::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_acr_repository_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_acr_repository_attributes::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_acr_repository_attributes {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn update_acr_repository_attributes(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    value: Option<&ChangeableAttributes>,
+) -> std::result::Result<(), update_acr_repository_attributes::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}", operation_config.base_path(), name);
+    let mut url = url::Url::parse(url_str).map_err(update_acr_repository_attributes::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::PATCH);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(update_acr_repository_attributes::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = if let Some(value) = value {
+        azure_core::to_json(value).map_err(update_acr_repository_attributes::Error::SerializeError)?
+    } else {
+        bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+    };
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(update_acr_repository_attributes::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(update_acr_repository_attributes::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::NO_CONTENT => Ok(()),
+        http::StatusCode::NOT_FOUND => Err(update_acr_repository_attributes::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| update_acr_repository_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(update_acr_repository_attributes::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod update_acr_repository_attributes {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn delete_acr_repository(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+) -> std::result::Result<DeletedRepository, delete_acr_repository::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}", operation_config.base_path(), name);
+    let mut url = url::Url::parse(url_str).map_err(delete_acr_repository::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::DELETE);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(delete_acr_repository::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(delete_acr_repository::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(delete_acr_repository::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::ACCEPTED => {
+            let rsp_body = rsp.body();
+            let rsp_value: DeletedRepository = serde_json::from_slice(rsp_body)
+                .map_err(|source| delete_acr_repository::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::NOT_FOUND => Err(delete_acr_repository::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| delete_acr_repository::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(delete_acr_repository::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod delete_acr_repository {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_acr_tags(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    last: Option<&str>,
+    n: Option<&str>,
+    orderby: Option<&str>,
+    digest: Option<&str>,
+) -> std::result::Result<AcrRepositoryTags, get_acr_tags::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}/_tags", operation_config.base_path(), name);
+    let mut url = url::Url::parse(url_str).map_err(get_acr_tags::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_acr_tags::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    if let Some(last) = last {
+        url.query_pairs_mut().append_pair("last", last);
+    }
+    if let Some(n) = n {
+        url.query_pairs_mut().append_pair("n", n);
+    }
+    if let Some(orderby) = orderby {
+        url.query_pairs_mut().append_pair("orderby", orderby);
+    }
+    if let Some(digest) = digest {
+        url.query_pairs_mut().append_pair("digest", digest);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_acr_tags::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_acr_tags::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrRepositoryTags =
+                serde_json::from_slice(rsp_body).map_err(|source| get_acr_tags::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::NOT_FOUND => Err(get_acr_tags::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors =
+                serde_json::from_slice(rsp_body).map_err(|source| get_acr_tags::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_acr_tags::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_acr_tags {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_acr_tag_attributes(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    reference: &str,
+) -> std::result::Result<AcrTagAttributes, get_acr_tag_attributes::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}/_tags/{}", operation_config.base_path(), name, reference);
+    let mut url = url::Url::parse(url_str).map_err(get_acr_tag_attributes::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_acr_tag_attributes::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(get_acr_tag_attributes::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_acr_tag_attributes::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrTagAttributes = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_acr_tag_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::NOT_FOUND => Err(get_acr_tag_attributes::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_acr_tag_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_acr_tag_attributes::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_acr_tag_attributes {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn update_acr_tag_attributes(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    reference: &str,
+    value: Option<&ChangeableAttributes>,
+) -> std::result::Result<(), update_acr_tag_attributes::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}/_tags/{}", operation_config.base_path(), name, reference);
+    let mut url = url::Url::parse(url_str).map_err(update_acr_tag_attributes::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::PATCH);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(update_acr_tag_attributes::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = if let Some(value) = value {
+        azure_core::to_json(value).map_err(update_acr_tag_attributes::Error::SerializeError)?
+    } else {
+        bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+    };
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(update_acr_tag_attributes::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(update_acr_tag_attributes::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::NO_CONTENT => Ok(()),
+        http::StatusCode::NOT_FOUND => Err(update_acr_tag_attributes::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| update_acr_tag_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(update_acr_tag_attributes::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod update_acr_tag_attributes {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn delete_acr_tag(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    reference: &str,
+) -> std::result::Result<(), delete_acr_tag::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}/_tags/{}", operation_config.base_path(), name, reference);
+    let mut url = url::Url::parse(url_str).map_err(delete_acr_tag::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::DELETE);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(delete_acr_tag::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(delete_acr_tag::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(delete_acr_tag::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::NO_CONTENT => Ok(()),
+        http::StatusCode::NOT_FOUND => Err(delete_acr_tag::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors =
+                serde_json::from_slice(rsp_body).map_err(|source| delete_acr_tag::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(delete_acr_tag::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod delete_acr_tag {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_acr_manifests(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    last: Option<&str>,
+    n: Option<&str>,
+    orderby: Option<&str>,
+) -> std::result::Result<AcrManifests, get_acr_manifests::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}/_manifests", operation_config.base_path(), name);
+    let mut url = url::Url::parse(url_str).map_err(get_acr_manifests::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_acr_manifests::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    if let Some(last) = last {
+        url.query_pairs_mut().append_pair("last", last);
+    }
+    if let Some(n) = n {
+        url.query_pairs_mut().append_pair("n", n);
+    }
+    if let Some(orderby) = orderby {
+        url.query_pairs_mut().append_pair("orderby", orderby);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_acr_manifests::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_acr_manifests::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrManifests =
+                serde_json::from_slice(rsp_body).map_err(|source| get_acr_manifests::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::NOT_FOUND => Err(get_acr_manifests::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors =
+                serde_json::from_slice(rsp_body).map_err(|source| get_acr_manifests::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_acr_manifests::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_acr_manifests {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_acr_manifest_attributes(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    reference: &str,
+) -> std::result::Result<AcrManifestAttributes, get_acr_manifest_attributes::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}/_manifests/{}", operation_config.base_path(), name, reference);
+    let mut url = url::Url::parse(url_str).map_err(get_acr_manifest_attributes::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_acr_manifest_attributes::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(get_acr_manifest_attributes::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_acr_manifest_attributes::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrManifestAttributes = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_acr_manifest_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::NOT_FOUND => Err(get_acr_manifest_attributes::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_acr_manifest_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_acr_manifest_attributes::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_acr_manifest_attributes {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn update_acr_manifest_attributes(
+    operation_config: &crate::OperationConfig,
+    name: &str,
+    reference: &str,
+    value: Option<&ChangeableAttributes>,
+) -> std::result::Result<(), update_acr_manifest_attributes::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/acr/v1/{}/_manifests/{}", operation_config.base_path(), name, reference);
+    let mut url = url::Url::parse(url_str).map_err(update_acr_manifest_attributes::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::PATCH);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(update_acr_manifest_attributes::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    let req_body = if let Some(value) = value {
+        azure_core::to_json(value).map_err(update_acr_manifest_attributes::Error::SerializeError)?
+    } else {
+        bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+    };
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(update_acr_manifest_attributes::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(update_acr_manifest_attributes::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::NO_CONTENT => Ok(()),
+        http::StatusCode::NOT_FOUND => Err(update_acr_manifest_attributes::Error::NotFound404 {}),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: AcrErrors = serde_json::from_slice(rsp_body)
+                .map_err(|source| update_acr_manifest_attributes::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(update_acr_manifest_attributes::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod update_acr_manifest_attributes {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        NotFound404 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::AcrErrors,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
diff --git a/services/svc/cosmos_db/Cargo.toml b/services/svc/cosmos_db/Cargo.toml
new file mode 100644
index 0000000000..94bf2a171a
--- /dev/null
+++ b/services/svc/cosmos_db/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_cosmos_db"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2019-02"]
+"package-2019-02" = []
diff --git a/services/svc/cosmos_db/src/lib.rs b/services/svc/cosmos_db/src/lib.rs
new file mode 100644
index 0000000000..8a1b8d0781
--- /dev/null
+++ b/services/svc/cosmos_db/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2019-02")]
+mod package_2019_02;
+use azure_core::setters;
+#[cfg(feature = "package-2019-02")]
+pub use package_2019_02::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/cosmos_db/src/package_2019_02/mod.rs b/services/svc/cosmos_db/src/package_2019_02/mod.rs
new file mode 100644
index 0000000000..138056f98d
--- /dev/null
+++ b/services/svc/cosmos_db/src/package_2019_02/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-02-02";
diff --git a/services/svc/cosmos_db/src/package_2019_02/models.rs b/services/svc/cosmos_db/src/package_2019_02/models.rs
new file mode 100644
index 0000000000..e653d7c96e
--- /dev/null
+++ b/services/svc/cosmos_db/src/package_2019_02/models.rs
@@ -0,0 +1,144 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableServiceError {
+    #[serde(rename = "Message", default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableServiceProperties {
+    #[serde(rename = "Logging", default, skip_serializing_if = "Option::is_none")]
+    pub logging: Option<Logging>,
+    #[serde(rename = "HourMetrics", default, skip_serializing_if = "Option::is_none")]
+    pub hour_metrics: Option<Metrics>,
+    #[serde(rename = "MinuteMetrics", default, skip_serializing_if = "Option::is_none")]
+    pub minute_metrics: Option<Metrics>,
+    #[serde(rename = "Cors", default, skip_serializing_if = "Vec::is_empty")]
+    pub cors: Vec<CorsRule>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Logging {
+    #[serde(rename = "Version")]
+    pub version: String,
+    #[serde(rename = "Delete")]
+    pub delete: bool,
+    #[serde(rename = "Read")]
+    pub read: bool,
+    #[serde(rename = "Write")]
+    pub write: bool,
+    #[serde(rename = "RetentionPolicy")]
+    pub retention_policy: RetentionPolicy,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Metrics {
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "Enabled")]
+    pub enabled: bool,
+    #[serde(rename = "IncludeAPIs", default, skip_serializing_if = "Option::is_none")]
+    pub include_ap_is: Option<bool>,
+    #[serde(rename = "RetentionPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub retention_policy: Option<RetentionPolicy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CorsRule {
+    #[serde(rename = "AllowedOrigins")]
+    pub allowed_origins: String,
+    #[serde(rename = "AllowedMethods")]
+    pub allowed_methods: String,
+    #[serde(rename = "AllowedHeaders")]
+    pub allowed_headers: String,
+    #[serde(rename = "ExposedHeaders")]
+    pub exposed_headers: String,
+    #[serde(rename = "MaxAgeInSeconds")]
+    pub max_age_in_seconds: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RetentionPolicy {
+    #[serde(rename = "Enabled")]
+    pub enabled: bool,
+    #[serde(rename = "Days", default, skip_serializing_if = "Option::is_none")]
+    pub days: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableServiceStats {
+    #[serde(rename = "GeoReplication", default, skip_serializing_if = "Option::is_none")]
+    pub geo_replication: Option<GeoReplication>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GeoReplication {
+    #[serde(rename = "Status")]
+    pub status: geo_replication::Status,
+    #[serde(rename = "LastSyncTime")]
+    pub last_sync_time: String,
+}
+pub mod geo_replication {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        #[serde(rename = "live")]
+        Live,
+        #[serde(rename = "bootstrap")]
+        Bootstrap,
+        #[serde(rename = "unavailable")]
+        Unavailable,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableProperties {
+    #[serde(rename = "TableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableResponse {
+    #[serde(flatten)]
+    pub table_response_properties: TableResponseProperties,
+    #[serde(rename = "odata.metadata", default, skip_serializing_if = "Option::is_none")]
+    pub odata_metadata: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableQueryResponse {
+    #[serde(rename = "odata.metadata", default, skip_serializing_if = "Option::is_none")]
+    pub odata_metadata: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<TableResponseProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableResponseProperties {
+    #[serde(rename = "TableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(rename = "odata.type", default, skip_serializing_if = "Option::is_none")]
+    pub odata_type: Option<String>,
+    #[serde(rename = "odata.id", default, skip_serializing_if = "Option::is_none")]
+    pub odata_id: Option<String>,
+    #[serde(rename = "odata.editLink", default, skip_serializing_if = "Option::is_none")]
+    pub odata_edit_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SignedIdentifier {
+    #[serde(rename = "Id")]
+    pub id: String,
+    #[serde(rename = "AccessPolicy")]
+    pub access_policy: AccessPolicy,
+}
+pub type SignedIdentifiers = Vec<SignedIdentifier>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AccessPolicy {
+    #[serde(rename = "Start")]
+    pub start: String,
+    #[serde(rename = "Expiry")]
+    pub expiry: String,
+    #[serde(rename = "Permission")]
+    pub permission: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableEntityQueryResponse {
+    #[serde(rename = "odata.metadata", default, skip_serializing_if = "Option::is_none")]
+    pub odata_metadata: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<TableEntityProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TableEntityProperties {}
diff --git a/services/svc/cosmos_db/src/package_2019_02/operations.rs b/services/svc/cosmos_db/src/package_2019_02/operations.rs
new file mode 100644
index 0000000000..7e1d3dce37
--- /dev/null
+++ b/services/svc/cosmos_db/src/package_2019_02/operations.rs
@@ -0,0 +1,950 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod table {
+    use crate::models::*;
+    pub async fn query(
+        operation_config: &crate::OperationConfig,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        data_service_version: &str,
+        format: Option<&str>,
+        top: Option<i32>,
+        select: Option<&str>,
+        filter: Option<&str>,
+        next_table_name: Option<&str>,
+    ) -> std::result::Result<TableQueryResponse, query::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Tables", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        req_builder = req_builder.header("DataServiceVersion", data_service_version);
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(next_table_name) = next_table_name {
+            url.query_pairs_mut().append_pair("NextTableName", next_table_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(query::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableQueryResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| query::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(query::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod query {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        data_service_version: &str,
+        format: Option<&str>,
+        table_properties: &TableProperties,
+        prefer: Option<&str>,
+    ) -> std::result::Result<create::Response, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Tables", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        req_builder = req_builder.header("DataServiceVersion", data_service_version);
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        let req_body = azure_core::to_json(table_properties).map_err(create::Error::SerializeError)?;
+        if let Some(prefer) = prefer {
+            req_builder = req_builder.header("Prefer", prefer);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Created201(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(create::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Created201(TableResponse),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        table: &str,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Tables('{}')", operation_config.base_path(), table);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_entities(
+        operation_config: &crate::OperationConfig,
+        timeout: Option<i64>,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        data_service_version: &str,
+        format: Option<&str>,
+        top: Option<i32>,
+        select: Option<&str>,
+        filter: Option<&str>,
+        table: &str,
+        next_partition_key: Option<&str>,
+        next_row_key: Option<&str>,
+    ) -> std::result::Result<TableEntityQueryResponse, query_entities::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}()", operation_config.base_path(), table);
+        let mut url = url::Url::parse(url_str).map_err(query_entities::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_entities::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timeout) = timeout {
+            url.query_pairs_mut().append_pair("timeout", timeout.to_string().as_str());
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        req_builder = req_builder.header("DataServiceVersion", data_service_version);
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(next_partition_key) = next_partition_key {
+            url.query_pairs_mut().append_pair("NextPartitionKey", next_partition_key);
+        }
+        if let Some(next_row_key) = next_row_key {
+            url.query_pairs_mut().append_pair("NextRowKey", next_row_key);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query_entities::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_entities::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableEntityQueryResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| query_entities::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError =
+                    serde_json::from_slice(rsp_body).map_err(|source| query_entities::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_entities::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_entities {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_entity_with_partition_and_row_key(
+        operation_config: &crate::OperationConfig,
+        timeout: Option<i64>,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        data_service_version: &str,
+        format: Option<&str>,
+        select: Option<&str>,
+        filter: Option<&str>,
+        table: &str,
+        partition_key: &str,
+        row_key: &str,
+    ) -> std::result::Result<TableEntityProperties, query_entity_with_partition_and_row_key::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}(PartitionKey='{}',RowKey='{}')",
+            operation_config.base_path(),
+            table,
+            partition_key,
+            row_key
+        );
+        let mut url = url::Url::parse(url_str).map_err(query_entity_with_partition_and_row_key::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_entity_with_partition_and_row_key::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timeout) = timeout {
+            url.query_pairs_mut().append_pair("timeout", timeout.to_string().as_str());
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        req_builder = req_builder.header("DataServiceVersion", data_service_version);
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_entity_with_partition_and_row_key::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_entity_with_partition_and_row_key::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableEntityProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_entity_with_partition_and_row_key::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_entity_with_partition_and_row_key::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_entity_with_partition_and_row_key::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_entity_with_partition_and_row_key {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_entity(
+        operation_config: &crate::OperationConfig,
+        timeout: Option<i64>,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        data_service_version: &str,
+        format: Option<&str>,
+        table_entity_properties: Option<&TableEntityProperties>,
+        table: &str,
+        partition_key: &str,
+        row_key: &str,
+        if_match: Option<&str>,
+    ) -> std::result::Result<(), update_entity::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}(PartitionKey='{}',RowKey='{}')",
+            operation_config.base_path(),
+            table,
+            partition_key,
+            row_key
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_entity::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_entity::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timeout) = timeout {
+            url.query_pairs_mut().append_pair("timeout", timeout.to_string().as_str());
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        req_builder = req_builder.header("DataServiceVersion", data_service_version);
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        let req_body = if let Some(table_entity_properties) = table_entity_properties {
+            azure_core::to_json(table_entity_properties).map_err(update_entity::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_entity::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_entity::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError =
+                    serde_json::from_slice(rsp_body).map_err(|source| update_entity::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_entity::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update_entity {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn merge_entity(
+        operation_config: &crate::OperationConfig,
+        timeout: Option<i64>,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        data_service_version: &str,
+        format: Option<&str>,
+        table_entity_properties: Option<&TableEntityProperties>,
+        table: &str,
+        partition_key: &str,
+        row_key: &str,
+        if_match: Option<&str>,
+    ) -> std::result::Result<(), merge_entity::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}(PartitionKey='{}',RowKey='{}')",
+            operation_config.base_path(),
+            table,
+            partition_key,
+            row_key
+        );
+        let mut url = url::Url::parse(url_str).map_err(merge_entity::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(merge_entity::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timeout) = timeout {
+            url.query_pairs_mut().append_pair("timeout", timeout.to_string().as_str());
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        req_builder = req_builder.header("DataServiceVersion", data_service_version);
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        let req_body = if let Some(table_entity_properties) = table_entity_properties {
+            azure_core::to_json(table_entity_properties).map_err(merge_entity::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(merge_entity::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(merge_entity::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError =
+                    serde_json::from_slice(rsp_body).map_err(|source| merge_entity::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(merge_entity::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod merge_entity {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_entity(
+        operation_config: &crate::OperationConfig,
+        timeout: Option<i64>,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        data_service_version: &str,
+        format: Option<&str>,
+        table: &str,
+        partition_key: &str,
+        row_key: &str,
+        if_match: &str,
+    ) -> std::result::Result<(), delete_entity::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}(PartitionKey='{}',RowKey='{}')",
+            operation_config.base_path(),
+            table,
+            partition_key,
+            row_key
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete_entity::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_entity::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timeout) = timeout {
+            url.query_pairs_mut().append_pair("timeout", timeout.to_string().as_str());
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        req_builder = req_builder.header("DataServiceVersion", data_service_version);
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        req_builder = req_builder.header("If-Match", if_match);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_entity::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_entity::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_entity::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_entity::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_entity {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_access_policy(
+        operation_config: &crate::OperationConfig,
+        timeout: Option<i64>,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        table: &str,
+        comp: &str,
+    ) -> std::result::Result<SignedIdentifiers, get_access_policy::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}", operation_config.base_path(), table);
+        let mut url = url::Url::parse(url_str).map_err(get_access_policy::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_access_policy::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timeout) = timeout {
+            url.query_pairs_mut().append_pair("timeout", timeout.to_string().as_str());
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        url.query_pairs_mut().append_pair("comp", comp);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_access_policy::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_access_policy::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SignedIdentifiers = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_access_policy::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_access_policy::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_access_policy::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_access_policy {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn insert_entity(
+        operation_config: &crate::OperationConfig,
+        timeout: Option<i64>,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        data_service_version: &str,
+        format: Option<&str>,
+        table_entity_properties: Option<&TableEntityProperties>,
+        table: &str,
+        prefer: Option<&str>,
+    ) -> std::result::Result<insert_entity::Response, insert_entity::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}", operation_config.base_path(), table);
+        let mut url = url::Url::parse(url_str).map_err(insert_entity::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(insert_entity::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(timeout) = timeout {
+            url.query_pairs_mut().append_pair("timeout", timeout.to_string().as_str());
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        req_builder = req_builder.header("DataServiceVersion", data_service_version);
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        let req_body = if let Some(table_entity_properties) = table_entity_properties {
+            azure_core::to_json(table_entity_properties).map_err(insert_entity::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        if let Some(prefer) = prefer {
+            req_builder = req_builder.header("Prefer", prefer);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(insert_entity::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(insert_entity::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableEntityProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| insert_entity::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(insert_entity::Response::Created201(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(insert_entity::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError =
+                    serde_json::from_slice(rsp_body).map_err(|source| insert_entity::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(insert_entity::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod insert_entity {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Created201(TableEntityProperties),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn set_access_policy(
+        operation_config: &crate::OperationConfig,
+        table_acl: Option<&SignedIdentifiers>,
+        timeout: Option<i64>,
+        x_ms_version: &str,
+        x_ms_client_request_id: Option<&str>,
+        table: &str,
+        comp: &str,
+    ) -> std::result::Result<(), set_access_policy::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}", operation_config.base_path(), table);
+        let mut url = url::Url::parse(url_str).map_err(set_access_policy::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(set_access_policy::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = if let Some(table_acl) = table_acl {
+            azure_core::to_json(table_acl).map_err(set_access_policy::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        if let Some(timeout) = timeout {
+            url.query_pairs_mut().append_pair("timeout", timeout.to_string().as_str());
+        }
+        req_builder = req_builder.header("x-ms-version", x_ms_version);
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        url.query_pairs_mut().append_pair("comp", comp);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(set_access_policy::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(set_access_policy::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TableServiceError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| set_access_policy::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(set_access_policy::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod set_access_policy {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TableServiceError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/datalake_analytics/Cargo.toml b/services/svc/datalake_analytics/Cargo.toml
new file mode 100644
index 0000000000..692bcd66bb
--- /dev/null
+++ b/services/svc/datalake_analytics/Cargo.toml
@@ -0,0 +1,28 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_datalake_analytics"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-catalog-2016-11"]
+"package-catalog-2016-11" = []
+"package-catalog-2015-10-preview" = []
+"package-job-2017-09-preview" = []
+"package-job-2016-11" = []
+"package-job-2016-03-preview" = []
+"package-job-2015-11-preview" = []
diff --git a/services/svc/datalake_analytics/src/lib.rs b/services/svc/datalake_analytics/src/lib.rs
new file mode 100644
index 0000000000..cc6cee00b7
--- /dev/null
+++ b/services/svc/datalake_analytics/src/lib.rs
@@ -0,0 +1,81 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-catalog-2016-11")]
+mod package_catalog_2016_11;
+#[cfg(feature = "package-catalog-2016-11")]
+pub use package_catalog_2016_11::{models, operations, API_VERSION};
+#[cfg(feature = "package-catalog-2015-10-preview")]
+mod package_catalog_2015_10_preview;
+#[cfg(feature = "package-catalog-2015-10-preview")]
+pub use package_catalog_2015_10_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-job-2017-09-preview")]
+mod package_job_2017_09_preview;
+#[cfg(feature = "package-job-2017-09-preview")]
+pub use package_job_2017_09_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-job-2016-11")]
+mod package_job_2016_11;
+#[cfg(feature = "package-job-2016-11")]
+pub use package_job_2016_11::{models, operations, API_VERSION};
+#[cfg(feature = "package-job-2016-03-preview")]
+mod package_job_2016_03_preview;
+#[cfg(feature = "package-job-2016-03-preview")]
+pub use package_job_2016_03_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-job-2015-11-preview")]
+mod package_job_2015_11_preview;
+use azure_core::setters;
+#[cfg(feature = "package-job-2015-11-preview")]
+pub use package_job_2015_11_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/mod.rs b/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/mod.rs
new file mode 100644
index 0000000000..da17bb56ce
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2015-10-01-preview";
diff --git a/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/models.rs b/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/models.rs
new file mode 100644
index 0000000000..f5d873a1cf
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/models.rs
@@ -0,0 +1,458 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters {
+    pub password: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlSecret {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "secretName", default, skip_serializing_if = "Option::is_none")]
+    pub secret_name: Option<String>,
+    #[serde(rename = "creationTime", default, skip_serializing_if = "Option::is_none")]
+    pub creation_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlExternalDataSource {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "externalDataSourceName", default, skip_serializing_if = "Option::is_none")]
+    pub external_data_source_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(rename = "providerString", default, skip_serializing_if = "Option::is_none")]
+    pub provider_string: Option<String>,
+    #[serde(rename = "pushdownTypes", default, skip_serializing_if = "Vec::is_empty")]
+    pub pushdown_types: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlExternalDataSourceList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlExternalDataSource>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlCredential {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "credentialName", default, skip_serializing_if = "Option::is_none")]
+    pub credential_name: Option<String>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlCredentialList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlCredential>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlProcedure {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "procName", default, skip_serializing_if = "Option::is_none")]
+    pub proc_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub definition: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlProcedureList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlProcedure>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableColumn {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlDirectedColumn {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub descending: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlDistributionInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub keys: Vec<USqlDirectedColumn>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i32>,
+    #[serde(rename = "dynamicCount", default, skip_serializing_if = "Option::is_none")]
+    pub dynamic_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlIndex {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "indexKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub index_keys: Vec<USqlDirectedColumn>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+    #[serde(rename = "distributionInfo", default, skip_serializing_if = "Option::is_none")]
+    pub distribution_info: Option<USqlDistributionInfo>,
+    #[serde(rename = "partitionFunction", default, skip_serializing_if = "Option::is_none")]
+    pub partition_function: Option<String>,
+    #[serde(rename = "partitionKeyList", default, skip_serializing_if = "Vec::is_empty")]
+    pub partition_key_list: Vec<String>,
+    #[serde(rename = "streamNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub stream_names: Vec<String>,
+    #[serde(rename = "isColumnstore", default, skip_serializing_if = "Option::is_none")]
+    pub is_columnstore: Option<bool>,
+    #[serde(rename = "indexId", default, skip_serializing_if = "Option::is_none")]
+    pub index_id: Option<i32>,
+    #[serde(rename = "isUnique", default, skip_serializing_if = "Option::is_none")]
+    pub is_unique: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DdlName {
+    #[serde(rename = "firstPart", default, skip_serializing_if = "Option::is_none")]
+    pub first_part: Option<String>,
+    #[serde(rename = "secondPart", default, skip_serializing_if = "Option::is_none")]
+    pub second_part: Option<String>,
+    #[serde(rename = "thirdPart", default, skip_serializing_if = "Option::is_none")]
+    pub third_part: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EntityId {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<DdlName>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExternalTable {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(rename = "dataSource", default, skip_serializing_if = "Option::is_none")]
+    pub data_source: Option<EntityId>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypeFieldInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTable {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(rename = "columnList", default, skip_serializing_if = "Vec::is_empty")]
+    pub column_list: Vec<USqlTableColumn>,
+    #[serde(rename = "indexList", default, skip_serializing_if = "Vec::is_empty")]
+    pub index_list: Vec<USqlIndex>,
+    #[serde(rename = "partitionKeyList", default, skip_serializing_if = "Vec::is_empty")]
+    pub partition_key_list: Vec<String>,
+    #[serde(rename = "externalTable", default, skip_serializing_if = "Option::is_none")]
+    pub external_table: Option<ExternalTable>,
+    #[serde(rename = "distributionInfo", default, skip_serializing_if = "Option::is_none")]
+    pub distribution_info: Option<USqlDistributionInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTable>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableType {
+    #[serde(flatten)]
+    pub u_sql_type: USqlType,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<TypeFieldInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableTypeList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTableType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlView {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "viewName", default, skip_serializing_if = "Option::is_none")]
+    pub view_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub definition: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlViewList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlView>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTablePartition {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "partitionName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_name: Option<String>,
+    #[serde(rename = "parentName", default, skip_serializing_if = "Option::is_none")]
+    pub parent_name: Option<DdlName>,
+    #[serde(rename = "indexId", default, skip_serializing_if = "Option::is_none")]
+    pub index_id: Option<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub label: Vec<String>,
+    #[serde(rename = "createDate", default, skip_serializing_if = "Option::is_none")]
+    pub create_date: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTablePartitionList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTablePartition>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableStatistics {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(rename = "statisticsName", default, skip_serializing_if = "Option::is_none")]
+    pub statistics_name: Option<String>,
+    #[serde(rename = "userStatName", default, skip_serializing_if = "Option::is_none")]
+    pub user_stat_name: Option<String>,
+    #[serde(rename = "statDataPath", default, skip_serializing_if = "Option::is_none")]
+    pub stat_data_path: Option<String>,
+    #[serde(rename = "createTime", default, skip_serializing_if = "Option::is_none")]
+    pub create_time: Option<String>,
+    #[serde(rename = "updateTime", default, skip_serializing_if = "Option::is_none")]
+    pub update_time: Option<String>,
+    #[serde(rename = "isUserCreated", default, skip_serializing_if = "Option::is_none")]
+    pub is_user_created: Option<bool>,
+    #[serde(rename = "isAutoCreated", default, skip_serializing_if = "Option::is_none")]
+    pub is_auto_created: Option<bool>,
+    #[serde(rename = "hasFilter", default, skip_serializing_if = "Option::is_none")]
+    pub has_filter: Option<bool>,
+    #[serde(rename = "filterDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub filter_definition: Option<String>,
+    #[serde(rename = "colNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub col_names: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableStatisticsList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTableStatistics>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlType {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "typeName", default, skip_serializing_if = "Option::is_none")]
+    pub type_name: Option<String>,
+    #[serde(rename = "typeFamily", default, skip_serializing_if = "Option::is_none")]
+    pub type_family: Option<String>,
+    #[serde(rename = "cSharpName", default, skip_serializing_if = "Option::is_none")]
+    pub c_sharp_name: Option<String>,
+    #[serde(rename = "fullCSharpName", default, skip_serializing_if = "Option::is_none")]
+    pub full_c_sharp_name: Option<String>,
+    #[serde(rename = "systemTypeId", default, skip_serializing_if = "Option::is_none")]
+    pub system_type_id: Option<i32>,
+    #[serde(rename = "userTypeId", default, skip_serializing_if = "Option::is_none")]
+    pub user_type_id: Option<i32>,
+    #[serde(rename = "schemaId", default, skip_serializing_if = "Option::is_none")]
+    pub schema_id: Option<i32>,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<i32>,
+    #[serde(rename = "isNullable", default, skip_serializing_if = "Option::is_none")]
+    pub is_nullable: Option<bool>,
+    #[serde(rename = "isUserDefined", default, skip_serializing_if = "Option::is_none")]
+    pub is_user_defined: Option<bool>,
+    #[serde(rename = "isAssemblyType", default, skip_serializing_if = "Option::is_none")]
+    pub is_assembly_type: Option<bool>,
+    #[serde(rename = "isTableType", default, skip_serializing_if = "Option::is_none")]
+    pub is_table_type: Option<bool>,
+    #[serde(rename = "isComplexType", default, skip_serializing_if = "Option::is_none")]
+    pub is_complex_type: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTypeList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableValuedFunction {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "tvfName", default, skip_serializing_if = "Option::is_none")]
+    pub tvf_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub definition: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableValuedFunctionList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTableValuedFunction>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssemblyFileInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<u_sql_assembly_file_info::Type>,
+    #[serde(rename = "originalPath", default, skip_serializing_if = "Option::is_none")]
+    pub original_path: Option<String>,
+    #[serde(rename = "contentPath", default, skip_serializing_if = "Option::is_none")]
+    pub content_path: Option<String>,
+}
+pub mod u_sql_assembly_file_info {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Assembly,
+        Resource,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssemblyDependencyInfo {
+    #[serde(rename = "entityId", default, skip_serializing_if = "Option::is_none")]
+    pub entity_id: Option<EntityId>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssembly {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "assemblyName", default, skip_serializing_if = "Option::is_none")]
+    pub assembly_name: Option<String>,
+    #[serde(rename = "clrName", default, skip_serializing_if = "Option::is_none")]
+    pub clr_name: Option<String>,
+    #[serde(rename = "isVisible", default, skip_serializing_if = "Option::is_none")]
+    pub is_visible: Option<bool>,
+    #[serde(rename = "isUserDefined", default, skip_serializing_if = "Option::is_none")]
+    pub is_user_defined: Option<bool>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<USqlAssemblyFileInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub dependencies: Vec<USqlAssemblyDependencyInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssemblyClr {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "assemblyClrName", default, skip_serializing_if = "Option::is_none")]
+    pub assembly_clr_name: Option<String>,
+    #[serde(rename = "clrName", default, skip_serializing_if = "Option::is_none")]
+    pub clr_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssemblyList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlAssemblyClr>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlSchema {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlSchemaList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlSchema>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlDatabase {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlDatabaseList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlDatabase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CatalogItem {
+    #[serde(rename = "computeAccountName", default, skip_serializing_if = "Option::is_none")]
+    pub compute_account_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CatalogItemList {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i32>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
diff --git a/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/operations.rs b/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/operations.rs
new file mode 100644
index 0000000000..305e29bb49
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_catalog_2015_10_preview/operations.rs
@@ -0,0 +1,2347 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod catalog {
+    use crate::models::*;
+    pub async fn get_secret(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        secret_name: &str,
+    ) -> std::result::Result<USqlSecret, get_secret::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/secrets/{}",
+            operation_config.base_path(),
+            database_name,
+            secret_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_secret::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_secret::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_secret::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_secret::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlSecret =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_secret::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_secret::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_secret {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_secret(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        secret_name: &str,
+        parameters: &DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters,
+    ) -> std::result::Result<USqlSecret, create_secret::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/secrets/{}",
+            operation_config.base_path(),
+            database_name,
+            secret_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_secret::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_secret::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create_secret::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_secret::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_secret::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlSecret =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_secret::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_secret::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_secret {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_secret(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        secret_name: &str,
+        parameters: &DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters,
+    ) -> std::result::Result<USqlSecret, update_secret::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/secrets/{}",
+            operation_config.base_path(),
+            database_name,
+            secret_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_secret::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_secret::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update_secret::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_secret::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_secret::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlSecret =
+                    serde_json::from_slice(rsp_body).map_err(|source| update_secret::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_secret::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_secret {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_secret(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        secret_name: &str,
+    ) -> std::result::Result<(), delete_secret::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/secrets/{}",
+            operation_config.base_path(),
+            database_name,
+            secret_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete_secret::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_secret::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_secret::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_secret::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(delete_secret::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod delete_secret {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_all_secrets(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+    ) -> std::result::Result<(), delete_all_secrets::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}/secrets", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_all_secrets::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_all_secrets::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_all_secrets::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_all_secrets::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(delete_all_secrets::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod delete_all_secrets {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_external_data_source(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        external_data_source_name: &str,
+    ) -> std::result::Result<USqlExternalDataSource, get_external_data_source::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/externaldatasources/{}",
+            operation_config.base_path(),
+            database_name,
+            external_data_source_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_external_data_source::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_external_data_source::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_external_data_source::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_external_data_source::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlExternalDataSource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_external_data_source::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_external_data_source::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_external_data_source {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_external_data_sources(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlExternalDataSourceList, list_external_data_sources::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/externaldatasources",
+            operation_config.base_path(),
+            database_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_external_data_sources::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_external_data_sources::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_external_data_sources::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_external_data_sources::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlExternalDataSourceList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_external_data_sources::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_external_data_sources::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_external_data_sources {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_credential(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        credential_name: &str,
+    ) -> std::result::Result<USqlCredential, get_credential::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/credentials/{}",
+            operation_config.base_path(),
+            database_name,
+            credential_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_credential::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_credential::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_credential::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_credential::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlCredential =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_credential::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_credential::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_credential {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_credentials(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlCredentialList, list_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/credentials",
+            operation_config.base_path(),
+            database_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlCredentialList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_credentials::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_procedure(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        procedure_name: &str,
+    ) -> std::result::Result<USqlProcedure, get_procedure::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/procedures/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            procedure_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_procedure::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_procedure::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_procedure::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_procedure::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlProcedure =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_procedure::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_procedure::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_procedure {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_procedures(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlProcedureList, list_procedures::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/procedures",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_procedures::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_procedures::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_procedures::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_procedures::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlProcedureList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_procedures::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_procedures::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_procedures {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+    ) -> std::result::Result<USqlTable, get_table::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_table::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTable =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_table::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_tables(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableList, list_tables::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_tables::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_tables::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_tables::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_tables::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_tables::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_tables::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_tables {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table_type(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_type_name: &str,
+    ) -> std::result::Result<USqlTableType, get_table_type::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tabletypes/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_type_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table_type::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table_type::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_table_type::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table_type::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableType =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_table_type::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table_type::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table_type {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_types(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableTypeList, list_table_types::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tabletypes",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_types::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_types::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_table_types::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_types::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableTypeList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_types::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_types::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_types {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_view(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        view_name: &str,
+    ) -> std::result::Result<USqlView, get_view::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/views/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            view_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_view::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_view::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_view::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_view::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlView =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_view::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_view::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_view {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_views(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlViewList, list_views::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/views",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_views::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_views::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_views::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_views::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlViewList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_views::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_views::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_views {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table_statistic(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        statistics_name: &str,
+    ) -> std::result::Result<USqlTableStatistics, get_table_statistic::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/statistics/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name,
+            statistics_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table_statistic::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table_statistic::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_table_statistic::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table_statistic::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableStatistics = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_table_statistic::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table_statistic::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table_statistic {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_statistics(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableStatisticsList, list_table_statistics::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/statistics",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_statistics::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_statistics::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_statistics::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_statistics::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableStatisticsList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_statistics::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_statistics::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_statistics {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table_partition(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        partition_name: &str,
+    ) -> std::result::Result<USqlTablePartition, get_table_partition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/partitions/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name,
+            partition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table_partition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table_partition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_table_partition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table_partition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTablePartition = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_table_partition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table_partition::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table_partition {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_partitions(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTablePartitionList, list_table_partitions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/partitions",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_partitions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_partitions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_partitions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_partitions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTablePartitionList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_partitions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_partitions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_partitions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_types(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTypeList, list_types::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/types",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_types::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_types::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_types::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_types::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTypeList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_types::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_types::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_types {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table_valued_function(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_valued_function_name: &str,
+    ) -> std::result::Result<USqlTableValuedFunction, get_table_valued_function::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tablevaluedfunctions/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_valued_function_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table_valued_function::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table_valued_function::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_table_valued_function::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table_valued_function::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableValuedFunction = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_table_valued_function::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table_valued_function::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table_valued_function {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_valued_functions(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableValuedFunctionList, list_table_valued_functions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tablevaluedfunctions",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_valued_functions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_valued_functions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_valued_functions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_valued_functions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableValuedFunctionList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_valued_functions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_valued_functions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_valued_functions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_assembly(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        assembly_name: &str,
+    ) -> std::result::Result<USqlAssembly, get_assembly::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/assemblies/{}",
+            operation_config.base_path(),
+            database_name,
+            assembly_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_assembly::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_assembly::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_assembly::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_assembly::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlAssembly =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_assembly::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_assembly::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_assembly {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_assemblies(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlAssemblyList, list_assemblies::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/assemblies",
+            operation_config.base_path(),
+            database_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_assemblies::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_assemblies::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_assemblies::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_assemblies::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlAssemblyList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_assemblies::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_assemblies::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_assemblies {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_schema(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+    ) -> std::result::Result<USqlSchema, get_schema::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_schema::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_schema::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_schema::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_schema::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlSchema =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_schema::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_schema::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_schema {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_schemas(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlSchemaList, list_schemas::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}/schemas", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(list_schemas::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_schemas::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_schemas::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_schemas::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlSchemaList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_schemas::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_schemas::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_schemas {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_database(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+    ) -> std::result::Result<USqlDatabase, get_database::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(get_database::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_database::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_database::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_database::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlDatabase =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_database::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_database::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_database {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_databases(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlDatabaseList, list_databases::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_databases::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_databases::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_databases::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_databases::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlDatabaseList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_databases::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_databases::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_databases {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/datalake_analytics/src/package_catalog_2016_11/mod.rs b/services/svc/datalake_analytics/src/package_catalog_2016_11/mod.rs
new file mode 100644
index 0000000000..6892af8bdd
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_catalog_2016_11/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2016-11-01";
diff --git a/services/svc/datalake_analytics/src/package_catalog_2016_11/models.rs b/services/svc/datalake_analytics/src/package_catalog_2016_11/models.rs
new file mode 100644
index 0000000000..8f20b6a3ea
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_catalog_2016_11/models.rs
@@ -0,0 +1,615 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AclCreateOrUpdateParameters {
+    #[serde(rename = "aceType")]
+    pub ace_type: acl_create_or_update_parameters::AceType,
+    #[serde(rename = "principalId")]
+    pub principal_id: String,
+    pub permission: acl_create_or_update_parameters::Permission,
+}
+pub mod acl_create_or_update_parameters {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AceType {
+        UserObj,
+        GroupObj,
+        Other,
+        User,
+        Group,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Permission {
+        None,
+        Use,
+        Create,
+        Drop,
+        Alter,
+        Write,
+        All,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AclDeleteParameters {
+    #[serde(rename = "aceType")]
+    pub ace_type: acl_delete_parameters::AceType,
+    #[serde(rename = "principalId")]
+    pub principal_id: String,
+}
+pub mod acl_delete_parameters {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AceType {
+        UserObj,
+        GroupObj,
+        Other,
+        User,
+        Group,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Acl {
+    #[serde(rename = "aceType", default, skip_serializing_if = "Option::is_none")]
+    pub ace_type: Option<acl::AceType>,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub permission: Option<acl::Permission>,
+}
+pub mod acl {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AceType {
+        UserObj,
+        GroupObj,
+        Other,
+        User,
+        Group,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Permission {
+        None,
+        Use,
+        Create,
+        Drop,
+        Alter,
+        Write,
+        All,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AclList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<Acl>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters {
+    pub password: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsCatalogCredentialCreateParameters {
+    pub password: String,
+    pub uri: String,
+    #[serde(rename = "userId")]
+    pub user_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsCatalogCredentialDeleteParameters {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsCatalogCredentialUpdateParameters {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+    #[serde(rename = "newPassword", default, skip_serializing_if = "Option::is_none")]
+    pub new_password: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlSecret {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "secretName", default, skip_serializing_if = "Option::is_none")]
+    pub secret_name: Option<String>,
+    #[serde(rename = "creationTime", default, skip_serializing_if = "Option::is_none")]
+    pub creation_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlExternalDataSource {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "externalDataSourceName", default, skip_serializing_if = "Option::is_none")]
+    pub external_data_source_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(rename = "providerString", default, skip_serializing_if = "Option::is_none")]
+    pub provider_string: Option<String>,
+    #[serde(rename = "pushdownTypes", default, skip_serializing_if = "Vec::is_empty")]
+    pub pushdown_types: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlExternalDataSourceList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlExternalDataSource>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlCredentialList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlCredential>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlCredential {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "credentialName", default, skip_serializing_if = "Option::is_none")]
+    pub credential_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlProcedure {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "procName", default, skip_serializing_if = "Option::is_none")]
+    pub proc_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub definition: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlProcedureList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlProcedure>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableColumn {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlDirectedColumn {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub descending: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlDistributionInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub keys: Vec<USqlDirectedColumn>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i32>,
+    #[serde(rename = "dynamicCount", default, skip_serializing_if = "Option::is_none")]
+    pub dynamic_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlIndex {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "indexKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub index_keys: Vec<USqlDirectedColumn>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+    #[serde(rename = "distributionInfo", default, skip_serializing_if = "Option::is_none")]
+    pub distribution_info: Option<USqlDistributionInfo>,
+    #[serde(rename = "partitionFunction", default, skip_serializing_if = "Option::is_none")]
+    pub partition_function: Option<String>,
+    #[serde(rename = "partitionKeyList", default, skip_serializing_if = "Vec::is_empty")]
+    pub partition_key_list: Vec<String>,
+    #[serde(rename = "streamNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub stream_names: Vec<String>,
+    #[serde(rename = "isColumnstore", default, skip_serializing_if = "Option::is_none")]
+    pub is_columnstore: Option<bool>,
+    #[serde(rename = "indexId", default, skip_serializing_if = "Option::is_none")]
+    pub index_id: Option<i32>,
+    #[serde(rename = "isUnique", default, skip_serializing_if = "Option::is_none")]
+    pub is_unique: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DdlName {
+    #[serde(rename = "firstPart", default, skip_serializing_if = "Option::is_none")]
+    pub first_part: Option<String>,
+    #[serde(rename = "secondPart", default, skip_serializing_if = "Option::is_none")]
+    pub second_part: Option<String>,
+    #[serde(rename = "thirdPart", default, skip_serializing_if = "Option::is_none")]
+    pub third_part: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EntityId {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<DdlName>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExternalTable {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(rename = "dataSource", default, skip_serializing_if = "Option::is_none")]
+    pub data_source: Option<EntityId>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypeFieldInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTablePreview {
+    #[serde(rename = "totalRowCount", default, skip_serializing_if = "Option::is_none")]
+    pub total_row_count: Option<i64>,
+    #[serde(rename = "totalColumnCount", default, skip_serializing_if = "Option::is_none")]
+    pub total_column_count: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub rows: Vec<Vec<String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub truncated: Option<bool>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub schema: Vec<USqlTableColumn>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTable {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(rename = "columnList", default, skip_serializing_if = "Vec::is_empty")]
+    pub column_list: Vec<USqlTableColumn>,
+    #[serde(rename = "indexList", default, skip_serializing_if = "Vec::is_empty")]
+    pub index_list: Vec<USqlIndex>,
+    #[serde(rename = "partitionKeyList", default, skip_serializing_if = "Vec::is_empty")]
+    pub partition_key_list: Vec<String>,
+    #[serde(rename = "externalTable", default, skip_serializing_if = "Option::is_none")]
+    pub external_table: Option<ExternalTable>,
+    #[serde(rename = "distributionInfo", default, skip_serializing_if = "Option::is_none")]
+    pub distribution_info: Option<USqlDistributionInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTable>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableFragment {
+    #[serde(rename = "parentId", default, skip_serializing_if = "Option::is_none")]
+    pub parent_id: Option<String>,
+    #[serde(rename = "fragmentId", default, skip_serializing_if = "Option::is_none")]
+    pub fragment_id: Option<String>,
+    #[serde(rename = "indexId", default, skip_serializing_if = "Option::is_none")]
+    pub index_id: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<i64>,
+    #[serde(rename = "rowCount", default, skip_serializing_if = "Option::is_none")]
+    pub row_count: Option<i64>,
+    #[serde(rename = "createDate", default, skip_serializing_if = "Option::is_none")]
+    pub create_date: Option<String>,
+    #[serde(rename = "streamPath", default, skip_serializing_if = "Option::is_none")]
+    pub stream_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableFragmentList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTableFragment>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableType {
+    #[serde(flatten)]
+    pub u_sql_type: USqlType,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<TypeFieldInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableTypeList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTableType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlView {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "viewName", default, skip_serializing_if = "Option::is_none")]
+    pub view_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub definition: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlViewList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlView>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlPackage {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub definition: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlPackageList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlPackage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTablePartition {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "partitionName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_name: Option<String>,
+    #[serde(rename = "parentName", default, skip_serializing_if = "Option::is_none")]
+    pub parent_name: Option<DdlName>,
+    #[serde(rename = "indexId", default, skip_serializing_if = "Option::is_none")]
+    pub index_id: Option<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub label: Vec<String>,
+    #[serde(rename = "createDate", default, skip_serializing_if = "Option::is_none")]
+    pub create_date: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTablePartitionList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTablePartition>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableStatistics {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(rename = "statisticsName", default, skip_serializing_if = "Option::is_none")]
+    pub statistics_name: Option<String>,
+    #[serde(rename = "userStatName", default, skip_serializing_if = "Option::is_none")]
+    pub user_stat_name: Option<String>,
+    #[serde(rename = "statDataPath", default, skip_serializing_if = "Option::is_none")]
+    pub stat_data_path: Option<String>,
+    #[serde(rename = "createTime", default, skip_serializing_if = "Option::is_none")]
+    pub create_time: Option<String>,
+    #[serde(rename = "updateTime", default, skip_serializing_if = "Option::is_none")]
+    pub update_time: Option<String>,
+    #[serde(rename = "isUserCreated", default, skip_serializing_if = "Option::is_none")]
+    pub is_user_created: Option<bool>,
+    #[serde(rename = "isAutoCreated", default, skip_serializing_if = "Option::is_none")]
+    pub is_auto_created: Option<bool>,
+    #[serde(rename = "hasFilter", default, skip_serializing_if = "Option::is_none")]
+    pub has_filter: Option<bool>,
+    #[serde(rename = "filterDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub filter_definition: Option<String>,
+    #[serde(rename = "colNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub col_names: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableStatisticsList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTableStatistics>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlType {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "typeName", default, skip_serializing_if = "Option::is_none")]
+    pub type_name: Option<String>,
+    #[serde(rename = "typeFamily", default, skip_serializing_if = "Option::is_none")]
+    pub type_family: Option<String>,
+    #[serde(rename = "cSharpName", default, skip_serializing_if = "Option::is_none")]
+    pub c_sharp_name: Option<String>,
+    #[serde(rename = "fullCSharpName", default, skip_serializing_if = "Option::is_none")]
+    pub full_c_sharp_name: Option<String>,
+    #[serde(rename = "systemTypeId", default, skip_serializing_if = "Option::is_none")]
+    pub system_type_id: Option<i32>,
+    #[serde(rename = "userTypeId", default, skip_serializing_if = "Option::is_none")]
+    pub user_type_id: Option<i32>,
+    #[serde(rename = "schemaId", default, skip_serializing_if = "Option::is_none")]
+    pub schema_id: Option<i32>,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<i32>,
+    #[serde(rename = "isNullable", default, skip_serializing_if = "Option::is_none")]
+    pub is_nullable: Option<bool>,
+    #[serde(rename = "isUserDefined", default, skip_serializing_if = "Option::is_none")]
+    pub is_user_defined: Option<bool>,
+    #[serde(rename = "isAssemblyType", default, skip_serializing_if = "Option::is_none")]
+    pub is_assembly_type: Option<bool>,
+    #[serde(rename = "isTableType", default, skip_serializing_if = "Option::is_none")]
+    pub is_table_type: Option<bool>,
+    #[serde(rename = "isComplexType", default, skip_serializing_if = "Option::is_none")]
+    pub is_complex_type: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTypeList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableValuedFunction {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+    #[serde(rename = "tvfName", default, skip_serializing_if = "Option::is_none")]
+    pub tvf_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub definition: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlTableValuedFunctionList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlTableValuedFunction>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssemblyFileInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<u_sql_assembly_file_info::Type>,
+    #[serde(rename = "originalPath", default, skip_serializing_if = "Option::is_none")]
+    pub original_path: Option<String>,
+    #[serde(rename = "contentPath", default, skip_serializing_if = "Option::is_none")]
+    pub content_path: Option<String>,
+}
+pub mod u_sql_assembly_file_info {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Assembly,
+        Resource,
+        Nodeploy,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssemblyDependencyInfo {
+    #[serde(rename = "entityId", default, skip_serializing_if = "Option::is_none")]
+    pub entity_id: Option<EntityId>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssembly {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "assemblyName", default, skip_serializing_if = "Option::is_none")]
+    pub assembly_name: Option<String>,
+    #[serde(rename = "clrName", default, skip_serializing_if = "Option::is_none")]
+    pub clr_name: Option<String>,
+    #[serde(rename = "isVisible", default, skip_serializing_if = "Option::is_none")]
+    pub is_visible: Option<bool>,
+    #[serde(rename = "isUserDefined", default, skip_serializing_if = "Option::is_none")]
+    pub is_user_defined: Option<bool>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<USqlAssemblyFileInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub dependencies: Vec<USqlAssemblyDependencyInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssemblyClr {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "assemblyClrName", default, skip_serializing_if = "Option::is_none")]
+    pub assembly_clr_name: Option<String>,
+    #[serde(rename = "clrName", default, skip_serializing_if = "Option::is_none")]
+    pub clr_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlAssemblyList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlAssemblyClr>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlSchema {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(rename = "schemaName", default, skip_serializing_if = "Option::is_none")]
+    pub schema_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlSchemaList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlSchema>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlDatabase {
+    #[serde(flatten)]
+    pub catalog_item: CatalogItem,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlDatabaseList {
+    #[serde(flatten)]
+    pub catalog_item_list: CatalogItemList,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<USqlDatabase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CatalogItem {
+    #[serde(rename = "computeAccountName", default, skip_serializing_if = "Option::is_none")]
+    pub compute_account_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CatalogItemList {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
diff --git a/services/svc/datalake_analytics/src/package_catalog_2016_11/operations.rs b/services/svc/datalake_analytics/src/package_catalog_2016_11/operations.rs
new file mode 100644
index 0000000000..48f21547b2
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_catalog_2016_11/operations.rs
@@ -0,0 +1,3506 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod catalog {
+    use crate::models::*;
+    pub async fn get_secret(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        secret_name: &str,
+    ) -> std::result::Result<USqlSecret, get_secret::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/secrets/{}",
+            operation_config.base_path(),
+            database_name,
+            secret_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_secret::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_secret::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_secret::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_secret::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlSecret =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_secret::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_secret::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_secret {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_secret(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        secret_name: &str,
+        parameters: &DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters,
+    ) -> std::result::Result<(), create_secret::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/secrets/{}",
+            operation_config.base_path(),
+            database_name,
+            secret_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_secret::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_secret::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create_secret::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_secret::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_secret::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_secret::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_secret {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_secret(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        secret_name: &str,
+        parameters: &DataLakeAnalyticsCatalogSecretCreateOrUpdateParameters,
+    ) -> std::result::Result<(), update_secret::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/secrets/{}",
+            operation_config.base_path(),
+            database_name,
+            secret_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_secret::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_secret::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update_secret::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_secret::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_secret::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_secret::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_secret {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_secret(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        secret_name: &str,
+    ) -> std::result::Result<(), delete_secret::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/secrets/{}",
+            operation_config.base_path(),
+            database_name,
+            secret_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete_secret::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_secret::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_secret::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_secret::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(delete_secret::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod delete_secret {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_all_secrets(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+    ) -> std::result::Result<(), delete_all_secrets::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}/secrets", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_all_secrets::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_all_secrets::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_all_secrets::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_all_secrets::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(delete_all_secrets::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod delete_all_secrets {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_credential(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        credential_name: &str,
+    ) -> std::result::Result<USqlCredential, get_credential::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/credentials/{}",
+            operation_config.base_path(),
+            database_name,
+            credential_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_credential::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_credential::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_credential::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_credential::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlCredential =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_credential::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_credential::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_credential {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_credential(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        credential_name: &str,
+        parameters: Option<&DataLakeAnalyticsCatalogCredentialDeleteParameters>,
+        cascade: Option<bool>,
+    ) -> std::result::Result<(), delete_credential::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/credentials/{}",
+            operation_config.base_path(),
+            database_name,
+            credential_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete_credential::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_credential::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = if let Some(parameters) = parameters {
+            azure_core::to_json(parameters).map_err(delete_credential::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        if let Some(cascade) = cascade {
+            url.query_pairs_mut().append_pair("cascade", cascade.to_string().as_str());
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_credential::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_credential::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(delete_credential::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod delete_credential {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_credential(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        credential_name: &str,
+        parameters: &DataLakeAnalyticsCatalogCredentialCreateParameters,
+    ) -> std::result::Result<(), create_credential::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/credentials/{}",
+            operation_config.base_path(),
+            database_name,
+            credential_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_credential::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_credential::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create_credential::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_credential::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_credential::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_credential::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_credential {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_credential(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        credential_name: &str,
+        parameters: &DataLakeAnalyticsCatalogCredentialUpdateParameters,
+    ) -> std::result::Result<(), update_credential::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/credentials/{}",
+            operation_config.base_path(),
+            database_name,
+            credential_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_credential::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_credential::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update_credential::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_credential::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_credential::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_credential::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_credential {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_credentials(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlCredentialList, list_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/credentials",
+            operation_config.base_path(),
+            database_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlCredentialList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_credentials::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_external_data_source(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        external_data_source_name: &str,
+    ) -> std::result::Result<USqlExternalDataSource, get_external_data_source::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/externaldatasources/{}",
+            operation_config.base_path(),
+            database_name,
+            external_data_source_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_external_data_source::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_external_data_source::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_external_data_source::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_external_data_source::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlExternalDataSource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_external_data_source::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_external_data_source::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_external_data_source {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_external_data_sources(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlExternalDataSourceList, list_external_data_sources::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/externaldatasources",
+            operation_config.base_path(),
+            database_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_external_data_sources::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_external_data_sources::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_external_data_sources::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_external_data_sources::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlExternalDataSourceList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_external_data_sources::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_external_data_sources::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_external_data_sources {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_procedure(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        procedure_name: &str,
+    ) -> std::result::Result<USqlProcedure, get_procedure::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/procedures/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            procedure_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_procedure::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_procedure::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_procedure::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_procedure::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlProcedure =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_procedure::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_procedure::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_procedure {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_procedures(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlProcedureList, list_procedures::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/procedures",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_procedures::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_procedures::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_procedures::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_procedures::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlProcedureList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_procedures::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_procedures::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_procedures {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+    ) -> std::result::Result<USqlTable, get_table::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_table::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTable =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_table::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_fragments(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableFragmentList, list_table_fragments::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/tablefragments",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_fragments::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_fragments::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_table_fragments::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_fragments::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableFragmentList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_fragments::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_fragments::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_fragments {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_tables(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+        basic: Option<bool>,
+    ) -> std::result::Result<USqlTableList, list_tables::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_tables::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_tables::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        if let Some(basic) = basic {
+            url.query_pairs_mut().append_pair("basic", basic.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_tables::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_tables::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_tables::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_tables::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_tables {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_statistics_by_database_and_schema(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableStatisticsList, list_table_statistics_by_database_and_schema::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/statistics",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_statistics_by_database_and_schema::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_statistics_by_database_and_schema::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_statistics_by_database_and_schema::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_statistics_by_database_and_schema::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableStatisticsList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_statistics_by_database_and_schema::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_statistics_by_database_and_schema::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_statistics_by_database_and_schema {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table_type(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_type_name: &str,
+    ) -> std::result::Result<USqlTableType, get_table_type::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tabletypes/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_type_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table_type::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table_type::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_table_type::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table_type::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableType =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_table_type::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table_type::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table_type {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_types(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableTypeList, list_table_types::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tabletypes",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_types::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_types::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_table_types::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_types::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableTypeList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_types::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_types::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_types {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_package(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        package_name: &str,
+    ) -> std::result::Result<USqlPackage, get_package::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/packages/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            package_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_package::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_package::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_package::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_package::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlPackage =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_package::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_package::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_package {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_packages(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlPackageList, list_packages::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/packages",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_packages::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_packages::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_packages::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_packages::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlPackageList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_packages::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_packages::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_packages {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_view(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        view_name: &str,
+    ) -> std::result::Result<USqlView, get_view::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/views/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            view_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_view::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_view::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_view::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_view::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlView =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_view::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_view::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_view {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_views(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlViewList, list_views::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/views",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_views::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_views::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_views::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_views::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlViewList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_views::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_views::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_views {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table_statistic(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        statistics_name: &str,
+    ) -> std::result::Result<USqlTableStatistics, get_table_statistic::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/statistics/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name,
+            statistics_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table_statistic::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table_statistic::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_table_statistic::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table_statistic::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableStatistics = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_table_statistic::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table_statistic::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table_statistic {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_statistics(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableStatisticsList, list_table_statistics::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/statistics",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_statistics::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_statistics::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_statistics::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_statistics::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableStatisticsList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_statistics::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_statistics::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_statistics {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn preview_table_partition(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        partition_name: &str,
+        max_rows: Option<i64>,
+        max_columns: Option<i64>,
+    ) -> std::result::Result<USqlTablePreview, preview_table_partition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/partitions/{}/previewrows",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name,
+            partition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(preview_table_partition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(preview_table_partition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(max_rows) = max_rows {
+            url.query_pairs_mut().append_pair("maxRows", max_rows.to_string().as_str());
+        }
+        if let Some(max_columns) = max_columns {
+            url.query_pairs_mut().append_pair("maxColumns", max_columns.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(preview_table_partition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(preview_table_partition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTablePreview = serde_json::from_slice(rsp_body)
+                    .map_err(|source| preview_table_partition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(preview_table_partition::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod preview_table_partition {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table_partition(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        partition_name: &str,
+    ) -> std::result::Result<USqlTablePartition, get_table_partition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/partitions/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name,
+            partition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table_partition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table_partition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_table_partition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table_partition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTablePartition = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_table_partition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table_partition::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table_partition {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn preview_table(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        max_rows: Option<i64>,
+        max_columns: Option<i64>,
+    ) -> std::result::Result<USqlTablePreview, preview_table::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/previewrows",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(preview_table::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(preview_table::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(max_rows) = max_rows {
+            url.query_pairs_mut().append_pair("maxRows", max_rows.to_string().as_str());
+        }
+        if let Some(max_columns) = max_columns {
+            url.query_pairs_mut().append_pair("maxColumns", max_columns.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(preview_table::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(preview_table::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTablePreview =
+                    serde_json::from_slice(rsp_body).map_err(|source| preview_table::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(preview_table::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod preview_table {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_partitions(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTablePartitionList, list_table_partitions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tables/{}/partitions",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_partitions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_partitions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_partitions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_partitions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTablePartitionList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_partitions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_partitions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_partitions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_types(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTypeList, list_types::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/types",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_types::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_types::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_types::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_types::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTypeList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_types::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_types::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_types {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_table_valued_function(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        table_valued_function_name: &str,
+    ) -> std::result::Result<USqlTableValuedFunction, get_table_valued_function::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tablevaluedfunctions/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name,
+            table_valued_function_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_table_valued_function::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_table_valued_function::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_table_valued_function::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_table_valued_function::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableValuedFunction = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_table_valued_function::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_table_valued_function::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_table_valued_function {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_valued_functions(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableValuedFunctionList, list_table_valued_functions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}/tablevaluedfunctions",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_valued_functions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_valued_functions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_valued_functions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_valued_functions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableValuedFunctionList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_valued_functions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_valued_functions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_valued_functions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_assembly(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        assembly_name: &str,
+    ) -> std::result::Result<USqlAssembly, get_assembly::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/assemblies/{}",
+            operation_config.base_path(),
+            database_name,
+            assembly_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_assembly::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_assembly::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_assembly::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_assembly::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlAssembly =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_assembly::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_assembly::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_assembly {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_assemblies(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlAssemblyList, list_assemblies::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/assemblies",
+            operation_config.base_path(),
+            database_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_assemblies::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_assemblies::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_assemblies::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_assemblies::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlAssemblyList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_assemblies::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_assemblies::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_assemblies {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_schema(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        schema_name: &str,
+    ) -> std::result::Result<USqlSchema, get_schema::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/schemas/{}",
+            operation_config.base_path(),
+            database_name,
+            schema_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_schema::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_schema::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_schema::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_schema::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlSchema =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_schema::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_schema::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_schema {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_schemas(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlSchemaList, list_schemas::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}/schemas", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(list_schemas::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_schemas::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_schemas::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_schemas::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlSchemaList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_schemas::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_schemas::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_schemas {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_statistics_by_database(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableStatisticsList, list_table_statistics_by_database::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/statistics",
+            operation_config.base_path(),
+            database_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_statistics_by_database::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_statistics_by_database::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_statistics_by_database::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_statistics_by_database::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableStatisticsList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_statistics_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_statistics_by_database::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_statistics_by_database {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_tables_by_database(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+        basic: Option<bool>,
+    ) -> std::result::Result<USqlTableList, list_tables_by_database::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}/tables", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(list_tables_by_database::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_tables_by_database::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        if let Some(basic) = basic {
+            url.query_pairs_mut().append_pair("basic", basic.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_tables_by_database::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_tables_by_database::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_tables_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_tables_by_database::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_tables_by_database {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_table_valued_functions_by_database(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlTableValuedFunctionList, list_table_valued_functions_by_database::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/catalog/usql/databases/{}/tablevaluedfunctions",
+            operation_config.base_path(),
+            database_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_table_valued_functions_by_database::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_table_valued_functions_by_database::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_table_valued_functions_by_database::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_table_valued_functions_by_database::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlTableValuedFunctionList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_table_valued_functions_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_table_valued_functions_by_database::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_table_valued_functions_by_database {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_views_by_database(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlViewList, list_views_by_database::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}/views", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(list_views_by_database::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_views_by_database::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_views_by_database::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_views_by_database::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlViewList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_views_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_views_by_database::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_views_by_database {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_acls_by_database(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<AclList, list_acls_by_database::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}/acl", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(list_acls_by_database::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_acls_by_database::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_acls_by_database::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_acls_by_database::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AclList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_acls_by_database::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_acls_by_database::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_acls_by_database {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_acls(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<AclList, list_acls::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/acl", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_acls::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_acls::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_acls::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_acls::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AclList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_acls::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_acls::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_acls {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_database(
+        operation_config: &crate::OperationConfig,
+        database_name: &str,
+    ) -> std::result::Result<USqlDatabase, get_database::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases/{}", operation_config.base_path(), database_name);
+        let mut url = url::Url::parse(url_str).map_err(get_database::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_database::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_database::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_database::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlDatabase =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_database::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_database::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_database {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_databases(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<USqlDatabaseList, list_databases::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/catalog/usql/databases", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_databases::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_databases::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_databases::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_databases::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: USqlDatabaseList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_databases::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_databases::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_databases {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/datalake_analytics/src/package_job_2015_11_preview/mod.rs b/services/svc/datalake_analytics/src/package_job_2015_11_preview/mod.rs
new file mode 100644
index 0000000000..4e03b77973
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2015_11_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2015-11-01-preview";
diff --git a/services/svc/datalake_analytics/src/package_job_2015_11_preview/models.rs b/services/svc/datalake_analytics/src/package_job_2015_11_preview/models.rs
new file mode 100644
index 0000000000..44d5d27149
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2015_11_preview/models.rs
@@ -0,0 +1,305 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatisticsVertexStage {
+    #[serde(rename = "dataRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_read: Option<i64>,
+    #[serde(rename = "dataReadCrossPod", default, skip_serializing_if = "Option::is_none")]
+    pub data_read_cross_pod: Option<i64>,
+    #[serde(rename = "dataReadIntraPod", default, skip_serializing_if = "Option::is_none")]
+    pub data_read_intra_pod: Option<i64>,
+    #[serde(rename = "dataToRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_to_read: Option<i64>,
+    #[serde(rename = "dataWritten", default, skip_serializing_if = "Option::is_none")]
+    pub data_written: Option<i64>,
+    #[serde(rename = "duplicateDiscardCount", default, skip_serializing_if = "Option::is_none")]
+    pub duplicate_discard_count: Option<i32>,
+    #[serde(rename = "failedCount", default, skip_serializing_if = "Option::is_none")]
+    pub failed_count: Option<i32>,
+    #[serde(rename = "maxVertexDataRead", default, skip_serializing_if = "Option::is_none")]
+    pub max_vertex_data_read: Option<i64>,
+    #[serde(rename = "minVertexDataRead", default, skip_serializing_if = "Option::is_none")]
+    pub min_vertex_data_read: Option<i64>,
+    #[serde(rename = "readFailureCount", default, skip_serializing_if = "Option::is_none")]
+    pub read_failure_count: Option<i32>,
+    #[serde(rename = "revocationCount", default, skip_serializing_if = "Option::is_none")]
+    pub revocation_count: Option<i32>,
+    #[serde(rename = "runningCount", default, skip_serializing_if = "Option::is_none")]
+    pub running_count: Option<i32>,
+    #[serde(rename = "scheduledCount", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_count: Option<i32>,
+    #[serde(rename = "stageName", default, skip_serializing_if = "Option::is_none")]
+    pub stage_name: Option<String>,
+    #[serde(rename = "succeededCount", default, skip_serializing_if = "Option::is_none")]
+    pub succeeded_count: Option<i32>,
+    #[serde(rename = "tempDataWritten", default, skip_serializing_if = "Option::is_none")]
+    pub temp_data_written: Option<i64>,
+    #[serde(rename = "totalCount", default, skip_serializing_if = "Option::is_none")]
+    pub total_count: Option<i32>,
+    #[serde(rename = "totalFailedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_failed_time: Option<String>,
+    #[serde(rename = "totalProgress", default, skip_serializing_if = "Option::is_none")]
+    pub total_progress: Option<i32>,
+    #[serde(rename = "totalSucceededTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_succeeded_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatistics {
+    #[serde(rename = "lastUpdateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub last_update_time_utc: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub stages: Vec<JobStatisticsVertexStage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDataPath {
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub command: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub paths: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStateAuditRecord {
+    #[serde(rename = "newState", default, skip_serializing_if = "Option::is_none")]
+    pub new_state: Option<String>,
+    #[serde(rename = "timeStamp", default, skip_serializing_if = "Option::is_none")]
+    pub time_stamp: Option<String>,
+    #[serde(rename = "requestedByUser", default, skip_serializing_if = "Option::is_none")]
+    pub requested_by_user: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "resourcePath", default, skip_serializing_if = "Option::is_none")]
+    pub resource_path: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<job_resource::Type>,
+}
+pub mod job_resource {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        VertexResource,
+        StatisticsResource,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<JobResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub statistics: Option<JobStatistics>,
+    #[serde(rename = "debugData", default, skip_serializing_if = "Option::is_none")]
+    pub debug_data: Option<JobDataPath>,
+    #[serde(rename = "algebraFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub algebra_file_path: Option<String>,
+    #[serde(rename = "totalCompilationTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_compilation_time: Option<String>,
+    #[serde(rename = "totalPauseTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_pause_time: Option<String>,
+    #[serde(rename = "totalQueuedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_queued_time: Option<String>,
+    #[serde(rename = "totalRunningTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_running_time: Option<String>,
+    #[serde(rename = "rootProcessNodeId", default, skip_serializing_if = "Option::is_none")]
+    pub root_process_node_id: Option<String>,
+    #[serde(rename = "yarnApplicationId", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_id: Option<String>,
+    #[serde(rename = "yarnApplicationTimeStamp", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_time_stamp: Option<i64>,
+    #[serde(rename = "compileMode", default, skip_serializing_if = "Option::is_none")]
+    pub compile_mode: Option<u_sql_job_properties::CompileMode>,
+}
+pub mod u_sql_job_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CompileMode {
+        Semantic,
+        Full,
+        SingleBox,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveJobStatementInfo {
+    #[serde(rename = "logLocation", default, skip_serializing_if = "Option::is_none")]
+    pub log_location: Option<String>,
+    #[serde(rename = "resultPreviewLocation", default, skip_serializing_if = "Option::is_none")]
+    pub result_preview_location: Option<String>,
+    #[serde(rename = "resultLocation", default, skip_serializing_if = "Option::is_none")]
+    pub result_location: Option<String>,
+    #[serde(rename = "errorMessage", default, skip_serializing_if = "Option::is_none")]
+    pub error_message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(rename = "statementInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub statement_info: Vec<HiveJobStatementInfo>,
+    #[serde(rename = "logsLocation", default, skip_serializing_if = "Option::is_none")]
+    pub logs_location: Option<String>,
+    #[serde(rename = "warehouseLocation", default, skip_serializing_if = "Option::is_none")]
+    pub warehouse_location: Option<String>,
+    #[serde(rename = "statementCount", default, skip_serializing_if = "Option::is_none")]
+    pub statement_count: Option<i32>,
+    #[serde(rename = "executedStatementCount", default, skip_serializing_if = "Option::is_none")]
+    pub executed_statement_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobProperties {
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<String>,
+    pub script: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobErrorDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+    #[serde(rename = "endOffset", default, skip_serializing_if = "Option::is_none")]
+    pub end_offset: Option<i32>,
+    #[serde(rename = "errorId", default, skip_serializing_if = "Option::is_none")]
+    pub error_id: Option<String>,
+    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
+    pub file_path: Option<String>,
+    #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
+    pub help_link: Option<String>,
+    #[serde(rename = "internalDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub internal_diagnostics: Option<String>,
+    #[serde(rename = "lineNumber", default, skip_serializing_if = "Option::is_none")]
+    pub line_number: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolution: Option<String>,
+    #[serde(rename = "InnerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Option<JobInnerError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<job_error_details::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(rename = "startOffset", default, skip_serializing_if = "Option::is_none")]
+    pub start_offset: Option<i32>,
+}
+pub mod job_error_details {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInnerError {
+    #[serde(rename = "diagnosticCode", default, skip_serializing_if = "Option::is_none")]
+    pub diagnostic_code: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<job_inner_error::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub component: Option<String>,
+    #[serde(rename = "errorId", default, skip_serializing_if = "Option::is_none")]
+    pub error_id: Option<String>,
+    #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
+    pub help_link: Option<String>,
+    #[serde(rename = "internalDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub internal_diagnostics: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolution: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+pub mod job_inner_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInformation {
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: job_information::Type,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub submitter: Option<String>,
+    #[serde(rename = "errorMessage", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_message: Vec<JobErrorDetails>,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<i32>,
+    #[serde(rename = "degreeOfParallelismPercent", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism_percent: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<i32>,
+    #[serde(rename = "submitTime", default, skip_serializing_if = "Option::is_none")]
+    pub submit_time: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<job_information::State>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<job_information::Result>,
+    #[serde(rename = "stateAuditRecords", default, skip_serializing_if = "Vec::is_empty")]
+    pub state_audit_records: Vec<JobStateAuditRecord>,
+    #[serde(rename = "hierarchyQueueNode", default, skip_serializing_if = "Option::is_none")]
+    pub hierarchy_queue_node: Option<String>,
+    pub properties: JobProperties,
+}
+pub mod job_information {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        USql,
+        Hive,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        Accepted,
+        Compiling,
+        Ended,
+        New,
+        Queued,
+        Running,
+        Scheduling,
+        Starting,
+        Paused,
+        WaitingForCapacity,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        None,
+        Succeeded,
+        Cancelled,
+        Failed,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInfoListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobInformation>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
diff --git a/services/svc/datalake_analytics/src/package_job_2015_11_preview/operations.rs b/services/svc/datalake_analytics/src/package_job_2015_11_preview/operations.rs
new file mode 100644
index 0000000000..8621ccbd69
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2015_11_preview/operations.rs
@@ -0,0 +1,441 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod job {
+    use crate::models::*;
+    pub async fn get_statistics(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<JobStatistics, get_statistics::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/GetStatistics", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get_statistics::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_statistics::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_statistics::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_statistics::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobStatistics =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_statistics::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_statistics::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_statistics {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_debug_data_path(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<JobDataPath, get_debug_data_path::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/GetDebugDataPath", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get_debug_data_path::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_debug_data_path::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_debug_data_path::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_debug_data_path::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDataPath = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_debug_data_path::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_debug_data_path::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_debug_data_path {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn build(
+        operation_config: &crate::OperationConfig,
+        parameters: &JobInformation,
+    ) -> std::result::Result<JobInformation, build::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/BuildJob", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(build::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(build::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(build::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(build::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(build::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| build::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(build::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod build {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel(operation_config: &crate::OperationConfig, job_identity: &str) -> std::result::Result<(), cancel::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/CancelJob", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(cancel::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, job_identity: &str) -> std::result::Result<JobInformation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+        parameters: &JobInformation,
+    ) -> std::result::Result<JobInformation, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+        search: Option<&str>,
+        format: Option<&str>,
+    ) -> std::result::Result<JobInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        if let Some(search) = search {
+            url.query_pairs_mut().append_pair("$search", search);
+        }
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/datalake_analytics/src/package_job_2016_03_preview/mod.rs b/services/svc/datalake_analytics/src/package_job_2016_03_preview/mod.rs
new file mode 100644
index 0000000000..4ccf329b6f
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2016_03_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2016-03-20-preview";
diff --git a/services/svc/datalake_analytics/src/package_job_2016_03_preview/models.rs b/services/svc/datalake_analytics/src/package_job_2016_03_preview/models.rs
new file mode 100644
index 0000000000..b24eaefe13
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2016_03_preview/models.rs
@@ -0,0 +1,330 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatisticsVertexStage {
+    #[serde(rename = "dataRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_read: Option<i64>,
+    #[serde(rename = "dataReadCrossPod", default, skip_serializing_if = "Option::is_none")]
+    pub data_read_cross_pod: Option<i64>,
+    #[serde(rename = "dataReadIntraPod", default, skip_serializing_if = "Option::is_none")]
+    pub data_read_intra_pod: Option<i64>,
+    #[serde(rename = "dataToRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_to_read: Option<i64>,
+    #[serde(rename = "dataWritten", default, skip_serializing_if = "Option::is_none")]
+    pub data_written: Option<i64>,
+    #[serde(rename = "duplicateDiscardCount", default, skip_serializing_if = "Option::is_none")]
+    pub duplicate_discard_count: Option<i32>,
+    #[serde(rename = "failedCount", default, skip_serializing_if = "Option::is_none")]
+    pub failed_count: Option<i32>,
+    #[serde(rename = "maxVertexDataRead", default, skip_serializing_if = "Option::is_none")]
+    pub max_vertex_data_read: Option<i64>,
+    #[serde(rename = "minVertexDataRead", default, skip_serializing_if = "Option::is_none")]
+    pub min_vertex_data_read: Option<i64>,
+    #[serde(rename = "readFailureCount", default, skip_serializing_if = "Option::is_none")]
+    pub read_failure_count: Option<i32>,
+    #[serde(rename = "revocationCount", default, skip_serializing_if = "Option::is_none")]
+    pub revocation_count: Option<i32>,
+    #[serde(rename = "runningCount", default, skip_serializing_if = "Option::is_none")]
+    pub running_count: Option<i32>,
+    #[serde(rename = "scheduledCount", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_count: Option<i32>,
+    #[serde(rename = "stageName", default, skip_serializing_if = "Option::is_none")]
+    pub stage_name: Option<String>,
+    #[serde(rename = "succeededCount", default, skip_serializing_if = "Option::is_none")]
+    pub succeeded_count: Option<i32>,
+    #[serde(rename = "tempDataWritten", default, skip_serializing_if = "Option::is_none")]
+    pub temp_data_written: Option<i64>,
+    #[serde(rename = "totalCount", default, skip_serializing_if = "Option::is_none")]
+    pub total_count: Option<i32>,
+    #[serde(rename = "totalFailedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_failed_time: Option<String>,
+    #[serde(rename = "totalProgress", default, skip_serializing_if = "Option::is_none")]
+    pub total_progress: Option<i32>,
+    #[serde(rename = "totalSucceededTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_succeeded_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatistics {
+    #[serde(rename = "lastUpdateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub last_update_time_utc: Option<String>,
+    #[serde(rename = "finalizingTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub finalizing_time_utc: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub stages: Vec<JobStatisticsVertexStage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDataPath {
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub command: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub paths: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStateAuditRecord {
+    #[serde(rename = "newState", default, skip_serializing_if = "Option::is_none")]
+    pub new_state: Option<String>,
+    #[serde(rename = "timeStamp", default, skip_serializing_if = "Option::is_none")]
+    pub time_stamp: Option<String>,
+    #[serde(rename = "requestedByUser", default, skip_serializing_if = "Option::is_none")]
+    pub requested_by_user: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "resourcePath", default, skip_serializing_if = "Option::is_none")]
+    pub resource_path: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<job_resource::Type>,
+}
+pub mod job_resource {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        VertexResource,
+        JobManagerResource,
+        StatisticsResource,
+        VertexResourceInUserFolder,
+        JobManagerResourceInUserFolder,
+        StatisticsResourceInUserFolder,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<JobResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub statistics: Option<JobStatistics>,
+    #[serde(rename = "debugData", default, skip_serializing_if = "Option::is_none")]
+    pub debug_data: Option<JobDataPath>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub diagnostics: Vec<Diagnostics>,
+    #[serde(rename = "algebraFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub algebra_file_path: Option<String>,
+    #[serde(rename = "totalCompilationTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_compilation_time: Option<String>,
+    #[serde(rename = "totalPauseTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_pause_time: Option<String>,
+    #[serde(rename = "totalQueuedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_queued_time: Option<String>,
+    #[serde(rename = "totalRunningTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_running_time: Option<String>,
+    #[serde(rename = "rootProcessNodeId", default, skip_serializing_if = "Option::is_none")]
+    pub root_process_node_id: Option<String>,
+    #[serde(rename = "yarnApplicationId", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_id: Option<String>,
+    #[serde(rename = "yarnApplicationTimeStamp", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_time_stamp: Option<i64>,
+    #[serde(rename = "compileMode", default, skip_serializing_if = "Option::is_none")]
+    pub compile_mode: Option<u_sql_job_properties::CompileMode>,
+}
+pub mod u_sql_job_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CompileMode {
+        Semantic,
+        Full,
+        SingleBox,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(rename = "logsLocation", default, skip_serializing_if = "Option::is_none")]
+    pub logs_location: Option<String>,
+    #[serde(rename = "outputLocation", default, skip_serializing_if = "Option::is_none")]
+    pub output_location: Option<String>,
+    #[serde(rename = "statementCount", default, skip_serializing_if = "Option::is_none")]
+    pub statement_count: Option<i32>,
+    #[serde(rename = "executedStatementCount", default, skip_serializing_if = "Option::is_none")]
+    pub executed_statement_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobProperties {
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<String>,
+    pub script: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Diagnostics {
+    #[serde(rename = "columnNumber", default, skip_serializing_if = "Option::is_none")]
+    pub column_number: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub end: Option<i32>,
+    #[serde(rename = "lineNumber", default, skip_serializing_if = "Option::is_none")]
+    pub line_number: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<diagnostics::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start: Option<i32>,
+}
+pub mod diagnostics {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobErrorDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+    #[serde(rename = "endOffset", default, skip_serializing_if = "Option::is_none")]
+    pub end_offset: Option<i32>,
+    #[serde(rename = "errorId", default, skip_serializing_if = "Option::is_none")]
+    pub error_id: Option<String>,
+    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
+    pub file_path: Option<String>,
+    #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
+    pub help_link: Option<String>,
+    #[serde(rename = "internalDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub internal_diagnostics: Option<String>,
+    #[serde(rename = "lineNumber", default, skip_serializing_if = "Option::is_none")]
+    pub line_number: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolution: Option<String>,
+    #[serde(rename = "innerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Option<JobInnerError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<job_error_details::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(rename = "startOffset", default, skip_serializing_if = "Option::is_none")]
+    pub start_offset: Option<i32>,
+}
+pub mod job_error_details {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInnerError {
+    #[serde(rename = "diagnosticCode", default, skip_serializing_if = "Option::is_none")]
+    pub diagnostic_code: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<job_inner_error::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub component: Option<String>,
+    #[serde(rename = "errorId", default, skip_serializing_if = "Option::is_none")]
+    pub error_id: Option<String>,
+    #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
+    pub help_link: Option<String>,
+    #[serde(rename = "internalDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub internal_diagnostics: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolution: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+pub mod job_inner_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInformation {
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: job_information::Type,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub submitter: Option<String>,
+    #[serde(rename = "errorMessage", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_message: Vec<JobErrorDetails>,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<i32>,
+    #[serde(rename = "degreeOfParallelismPercent", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism_percent: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<i32>,
+    #[serde(rename = "submitTime", default, skip_serializing_if = "Option::is_none")]
+    pub submit_time: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<job_information::State>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<job_information::Result>,
+    #[serde(rename = "logFolder", default, skip_serializing_if = "Option::is_none")]
+    pub log_folder: Option<String>,
+    #[serde(rename = "logFilePatterns", default, skip_serializing_if = "Vec::is_empty")]
+    pub log_file_patterns: Vec<String>,
+    #[serde(rename = "stateAuditRecords", default, skip_serializing_if = "Vec::is_empty")]
+    pub state_audit_records: Vec<JobStateAuditRecord>,
+    #[serde(rename = "hierarchyQueueNode", default, skip_serializing_if = "Option::is_none")]
+    pub hierarchy_queue_node: Option<String>,
+    pub properties: JobProperties,
+}
+pub mod job_information {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        USql,
+        Hive,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        Accepted,
+        Compiling,
+        Ended,
+        New,
+        Queued,
+        Running,
+        Scheduling,
+        Starting,
+        Paused,
+        WaitingForCapacity,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        None,
+        Succeeded,
+        Cancelled,
+        Failed,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInfoListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobInformation>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
diff --git a/services/svc/datalake_analytics/src/package_job_2016_03_preview/operations.rs b/services/svc/datalake_analytics/src/package_job_2016_03_preview/operations.rs
new file mode 100644
index 0000000000..55533577de
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2016_03_preview/operations.rs
@@ -0,0 +1,440 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod job {
+    use crate::models::*;
+    pub async fn get_statistics(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<JobStatistics, get_statistics::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/GetStatistics", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get_statistics::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_statistics::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_statistics::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_statistics::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobStatistics =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_statistics::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_statistics::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_statistics {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_debug_data_path(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<JobDataPath, get_debug_data_path::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/GetDebugDataPath", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get_debug_data_path::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_debug_data_path::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_debug_data_path::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_debug_data_path::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDataPath = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_debug_data_path::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_debug_data_path::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_debug_data_path {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn build(
+        operation_config: &crate::OperationConfig,
+        parameters: &JobInformation,
+    ) -> std::result::Result<JobInformation, build::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/BuildJob", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(build::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(build::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(build::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(build::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(build::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| build::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(build::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod build {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel(operation_config: &crate::OperationConfig, job_identity: &str) -> std::result::Result<(), cancel::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/CancelJob", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(cancel::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, job_identity: &str) -> std::result::Result<JobInformation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+        parameters: &JobInformation,
+    ) -> std::result::Result<JobInformation, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        expand: Option<&str>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+        search: Option<&str>,
+        format: Option<&str>,
+    ) -> std::result::Result<JobInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        if let Some(search) = search {
+            url.query_pairs_mut().append_pair("$search", search);
+        }
+        if let Some(format) = format {
+            url.query_pairs_mut().append_pair("$format", format);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/datalake_analytics/src/package_job_2016_11/mod.rs b/services/svc/datalake_analytics/src/package_job_2016_11/mod.rs
new file mode 100644
index 0000000000..6892af8bdd
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2016_11/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2016-11-01";
diff --git a/services/svc/datalake_analytics/src/package_job_2016_11/models.rs b/services/svc/datalake_analytics/src/package_job_2016_11/models.rs
new file mode 100644
index 0000000000..00b876baef
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2016_11/models.rs
@@ -0,0 +1,491 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatisticsVertexStage {
+    #[serde(rename = "dataRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_read: Option<i64>,
+    #[serde(rename = "dataReadCrossPod", default, skip_serializing_if = "Option::is_none")]
+    pub data_read_cross_pod: Option<i64>,
+    #[serde(rename = "dataReadIntraPod", default, skip_serializing_if = "Option::is_none")]
+    pub data_read_intra_pod: Option<i64>,
+    #[serde(rename = "dataToRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_to_read: Option<i64>,
+    #[serde(rename = "dataWritten", default, skip_serializing_if = "Option::is_none")]
+    pub data_written: Option<i64>,
+    #[serde(rename = "duplicateDiscardCount", default, skip_serializing_if = "Option::is_none")]
+    pub duplicate_discard_count: Option<i32>,
+    #[serde(rename = "failedCount", default, skip_serializing_if = "Option::is_none")]
+    pub failed_count: Option<i32>,
+    #[serde(rename = "maxVertexDataRead", default, skip_serializing_if = "Option::is_none")]
+    pub max_vertex_data_read: Option<i64>,
+    #[serde(rename = "minVertexDataRead", default, skip_serializing_if = "Option::is_none")]
+    pub min_vertex_data_read: Option<i64>,
+    #[serde(rename = "readFailureCount", default, skip_serializing_if = "Option::is_none")]
+    pub read_failure_count: Option<i32>,
+    #[serde(rename = "revocationCount", default, skip_serializing_if = "Option::is_none")]
+    pub revocation_count: Option<i32>,
+    #[serde(rename = "runningCount", default, skip_serializing_if = "Option::is_none")]
+    pub running_count: Option<i32>,
+    #[serde(rename = "scheduledCount", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_count: Option<i32>,
+    #[serde(rename = "stageName", default, skip_serializing_if = "Option::is_none")]
+    pub stage_name: Option<String>,
+    #[serde(rename = "succeededCount", default, skip_serializing_if = "Option::is_none")]
+    pub succeeded_count: Option<i32>,
+    #[serde(rename = "tempDataWritten", default, skip_serializing_if = "Option::is_none")]
+    pub temp_data_written: Option<i64>,
+    #[serde(rename = "totalCount", default, skip_serializing_if = "Option::is_none")]
+    pub total_count: Option<i32>,
+    #[serde(rename = "totalFailedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_failed_time: Option<String>,
+    #[serde(rename = "totalProgress", default, skip_serializing_if = "Option::is_none")]
+    pub total_progress: Option<i32>,
+    #[serde(rename = "totalSucceededTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_succeeded_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatistics {
+    #[serde(rename = "lastUpdateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub last_update_time_utc: Option<String>,
+    #[serde(rename = "finalizingTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub finalizing_time_utc: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub stages: Vec<JobStatisticsVertexStage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDataPath {
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub command: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub paths: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStateAuditRecord {
+    #[serde(rename = "newState", default, skip_serializing_if = "Option::is_none")]
+    pub new_state: Option<String>,
+    #[serde(rename = "timeStamp", default, skip_serializing_if = "Option::is_none")]
+    pub time_stamp: Option<String>,
+    #[serde(rename = "requestedByUser", default, skip_serializing_if = "Option::is_none")]
+    pub requested_by_user: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "resourcePath", default, skip_serializing_if = "Option::is_none")]
+    pub resource_path: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<job_resource::Type>,
+}
+pub mod job_resource {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        VertexResource,
+        JobManagerResource,
+        StatisticsResource,
+        VertexResourceInUserFolder,
+        JobManagerResourceInUserFolder,
+        StatisticsResourceInUserFolder,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<JobResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub statistics: Option<JobStatistics>,
+    #[serde(rename = "debugData", default, skip_serializing_if = "Option::is_none")]
+    pub debug_data: Option<JobDataPath>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub diagnostics: Vec<Diagnostics>,
+    #[serde(rename = "algebraFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub algebra_file_path: Option<String>,
+    #[serde(rename = "totalCompilationTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_compilation_time: Option<String>,
+    #[serde(rename = "totalPauseTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_pause_time: Option<String>,
+    #[serde(rename = "totalQueuedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_queued_time: Option<String>,
+    #[serde(rename = "totalRunningTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_running_time: Option<String>,
+    #[serde(rename = "rootProcessNodeId", default, skip_serializing_if = "Option::is_none")]
+    pub root_process_node_id: Option<String>,
+    #[serde(rename = "yarnApplicationId", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_id: Option<String>,
+    #[serde(rename = "yarnApplicationTimeStamp", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_time_stamp: Option<i64>,
+    #[serde(rename = "compileMode", default, skip_serializing_if = "Option::is_none")]
+    pub compile_mode: Option<u_sql_job_properties::CompileMode>,
+}
+pub mod u_sql_job_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CompileMode {
+        Semantic,
+        Full,
+        SingleBox,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(rename = "logsLocation", default, skip_serializing_if = "Option::is_none")]
+    pub logs_location: Option<String>,
+    #[serde(rename = "outputLocation", default, skip_serializing_if = "Option::is_none")]
+    pub output_location: Option<String>,
+    #[serde(rename = "statementCount", default, skip_serializing_if = "Option::is_none")]
+    pub statement_count: Option<i32>,
+    #[serde(rename = "executedStatementCount", default, skip_serializing_if = "Option::is_none")]
+    pub executed_statement_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobProperties {
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<String>,
+    pub script: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateUSqlJobProperties {
+    #[serde(flatten)]
+    pub create_job_properties: CreateJobProperties,
+    #[serde(rename = "compileMode", default, skip_serializing_if = "Option::is_none")]
+    pub compile_mode: Option<create_u_sql_job_properties::CompileMode>,
+}
+pub mod create_u_sql_job_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CompileMode {
+        Semantic,
+        Full,
+        SingleBox,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateJobProperties {
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<String>,
+    pub script: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Diagnostics {
+    #[serde(rename = "columnNumber", default, skip_serializing_if = "Option::is_none")]
+    pub column_number: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub end: Option<i32>,
+    #[serde(rename = "lineNumber", default, skip_serializing_if = "Option::is_none")]
+    pub line_number: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<diagnostics::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start: Option<i32>,
+}
+pub mod diagnostics {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+        SevereWarning,
+        Deprecated,
+        UserWarning,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobErrorDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+    #[serde(rename = "endOffset", default, skip_serializing_if = "Option::is_none")]
+    pub end_offset: Option<i32>,
+    #[serde(rename = "errorId", default, skip_serializing_if = "Option::is_none")]
+    pub error_id: Option<String>,
+    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
+    pub file_path: Option<String>,
+    #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
+    pub help_link: Option<String>,
+    #[serde(rename = "internalDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub internal_diagnostics: Option<String>,
+    #[serde(rename = "lineNumber", default, skip_serializing_if = "Option::is_none")]
+    pub line_number: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolution: Option<String>,
+    #[serde(rename = "innerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Option<JobInnerError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<job_error_details::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(rename = "startOffset", default, skip_serializing_if = "Option::is_none")]
+    pub start_offset: Option<i32>,
+}
+pub mod job_error_details {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+        SevereWarning,
+        Deprecated,
+        UserWarning,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInnerError {
+    #[serde(rename = "diagnosticCode", default, skip_serializing_if = "Option::is_none")]
+    pub diagnostic_code: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<job_inner_error::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub component: Option<String>,
+    #[serde(rename = "errorId", default, skip_serializing_if = "Option::is_none")]
+    pub error_id: Option<String>,
+    #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
+    pub help_link: Option<String>,
+    #[serde(rename = "internalDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub internal_diagnostics: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolution: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "innerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Option<JobInnerError>,
+}
+pub mod job_inner_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+        SevereWarning,
+        Deprecated,
+        UserWarning,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobRelationshipProperties {
+    #[serde(rename = "pipelineId", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_id: Option<String>,
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(rename = "pipelineUri", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_uri: Option<String>,
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "recurrenceId")]
+    pub recurrence_id: String,
+    #[serde(rename = "recurrenceName", default, skip_serializing_if = "Option::is_none")]
+    pub recurrence_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobPipelineInformationListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobPipelineInformation>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobPipelineInformation {
+    #[serde(rename = "pipelineId", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_id: Option<String>,
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(rename = "pipelineUri", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_uri: Option<String>,
+    #[serde(rename = "numJobsFailed", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_failed: Option<i32>,
+    #[serde(rename = "numJobsCanceled", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_canceled: Option<i32>,
+    #[serde(rename = "numJobsSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_succeeded: Option<i32>,
+    #[serde(rename = "auHoursFailed", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_failed: Option<f64>,
+    #[serde(rename = "auHoursCanceled", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_canceled: Option<f64>,
+    #[serde(rename = "auHoursSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_succeeded: Option<f64>,
+    #[serde(rename = "lastSubmitTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_submit_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub runs: Vec<JobPipelineRunInformation>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub recurrences: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobRecurrenceInformationListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobRecurrenceInformation>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobRecurrenceInformation {
+    #[serde(rename = "recurrenceId", default, skip_serializing_if = "Option::is_none")]
+    pub recurrence_id: Option<String>,
+    #[serde(rename = "recurrenceName", default, skip_serializing_if = "Option::is_none")]
+    pub recurrence_name: Option<String>,
+    #[serde(rename = "numJobsFailed", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_failed: Option<i32>,
+    #[serde(rename = "numJobsCanceled", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_canceled: Option<i32>,
+    #[serde(rename = "numJobsSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_succeeded: Option<i32>,
+    #[serde(rename = "auHoursFailed", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_failed: Option<f64>,
+    #[serde(rename = "auHoursCanceled", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_canceled: Option<f64>,
+    #[serde(rename = "auHoursSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_succeeded: Option<f64>,
+    #[serde(rename = "lastSubmitTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_submit_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobPipelineRunInformation {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "lastSubmitTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_submit_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateJobParameters {
+    #[serde(flatten)]
+    pub base_job_parameters: BaseJobParameters,
+    pub name: String,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<i32>,
+    #[serde(rename = "degreeOfParallelismPercent", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism_percent: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<i32>,
+    #[serde(rename = "logFilePatterns", default, skip_serializing_if = "Vec::is_empty")]
+    pub log_file_patterns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<JobRelationshipProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BuildJobParameters {
+    #[serde(flatten)]
+    pub base_job_parameters: BaseJobParameters,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BaseJobParameters {
+    #[serde(rename = "type")]
+    pub type_: base_job_parameters::Type,
+    pub properties: CreateJobProperties,
+}
+pub mod base_job_parameters {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        USql,
+        Hive,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInformationBasic {
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: job_information_basic::Type,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub submitter: Option<String>,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<i32>,
+    #[serde(rename = "degreeOfParallelismPercent", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism_percent: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<i32>,
+    #[serde(rename = "submitTime", default, skip_serializing_if = "Option::is_none")]
+    pub submit_time: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<job_information_basic::State>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<job_information_basic::Result>,
+    #[serde(rename = "logFolder", default, skip_serializing_if = "Option::is_none")]
+    pub log_folder: Option<String>,
+    #[serde(rename = "logFilePatterns", default, skip_serializing_if = "Vec::is_empty")]
+    pub log_file_patterns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<JobRelationshipProperties>,
+    #[serde(rename = "hierarchyQueueNode", default, skip_serializing_if = "Option::is_none")]
+    pub hierarchy_queue_node: Option<String>,
+}
+pub mod job_information_basic {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        USql,
+        Hive,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        Accepted,
+        Compiling,
+        Ended,
+        New,
+        Queued,
+        Running,
+        Scheduling,
+        Starting,
+        Paused,
+        WaitingForCapacity,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        None,
+        Succeeded,
+        Cancelled,
+        Failed,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInformation {
+    #[serde(flatten)]
+    pub job_information_basic: JobInformationBasic,
+    #[serde(rename = "errorMessage", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_message: Vec<JobErrorDetails>,
+    #[serde(rename = "stateAuditRecords", default, skip_serializing_if = "Vec::is_empty")]
+    pub state_audit_records: Vec<JobStateAuditRecord>,
+    pub properties: JobProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInfoListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobInformationBasic>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
diff --git a/services/svc/datalake_analytics/src/package_job_2016_11/operations.rs b/services/svc/datalake_analytics/src/package_job_2016_11/operations.rs
new file mode 100644
index 0000000000..2fe578200e
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2016_11/operations.rs
@@ -0,0 +1,691 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod pipeline {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        start_date_time: Option<&str>,
+        end_date_time: Option<&str>,
+    ) -> std::result::Result<JobPipelineInformationListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(start_date_time) = start_date_time {
+            url.query_pairs_mut().append_pair("startDateTime", start_date_time);
+        }
+        if let Some(end_date_time) = end_date_time {
+            url.query_pairs_mut().append_pair("endDateTime", end_date_time);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobPipelineInformationListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        pipeline_identity: &str,
+        start_date_time: Option<&str>,
+        end_date_time: Option<&str>,
+    ) -> std::result::Result<JobPipelineInformation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_identity);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(start_date_time) = start_date_time {
+            url.query_pairs_mut().append_pair("startDateTime", start_date_time);
+        }
+        if let Some(end_date_time) = end_date_time {
+            url.query_pairs_mut().append_pair("endDateTime", end_date_time);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobPipelineInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod recurrence {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        start_date_time: Option<&str>,
+        end_date_time: Option<&str>,
+    ) -> std::result::Result<JobRecurrenceInformationListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/recurrences", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(start_date_time) = start_date_time {
+            url.query_pairs_mut().append_pair("startDateTime", start_date_time);
+        }
+        if let Some(end_date_time) = end_date_time {
+            url.query_pairs_mut().append_pair("endDateTime", end_date_time);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobRecurrenceInformationListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        recurrence_identity: &str,
+        start_date_time: Option<&str>,
+        end_date_time: Option<&str>,
+    ) -> std::result::Result<JobRecurrenceInformation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/recurrences/{}", operation_config.base_path(), recurrence_identity);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(start_date_time) = start_date_time {
+            url.query_pairs_mut().append_pair("startDateTime", start_date_time);
+        }
+        if let Some(end_date_time) = end_date_time {
+            url.query_pairs_mut().append_pair("endDateTime", end_date_time);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobRecurrenceInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod job {
+    use crate::models::*;
+    pub async fn get_statistics(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<JobStatistics, get_statistics::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/GetStatistics", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get_statistics::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_statistics::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_statistics::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_statistics::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobStatistics =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_statistics::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_statistics::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_statistics {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_debug_data_path(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<JobDataPath, get_debug_data_path::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/GetDebugDataPath", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get_debug_data_path::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_debug_data_path::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_debug_data_path::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_debug_data_path::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDataPath = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_debug_data_path::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_debug_data_path::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_debug_data_path {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn build(
+        operation_config: &crate::OperationConfig,
+        parameters: &BuildJobParameters,
+    ) -> std::result::Result<JobInformation, build::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/BuildJob", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(build::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(build::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(build::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(build::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(build::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| build::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(build::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod build {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel(operation_config: &crate::OperationConfig, job_identity: &str) -> std::result::Result<(), cancel::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}/CancelJob", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(cancel::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, job_identity: &str) -> std::result::Result<JobInformation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+        parameters: &CreateJobParameters,
+    ) -> std::result::Result<JobInformation, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<JobInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/Jobs", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/datalake_analytics/src/package_job_2017_09_preview/mod.rs b/services/svc/datalake_analytics/src/package_job_2017_09_preview/mod.rs
new file mode 100644
index 0000000000..1dde1d2217
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2017_09_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2017-09-01-preview";
diff --git a/services/svc/datalake_analytics/src/package_job_2017_09_preview/models.rs b/services/svc/datalake_analytics/src/package_job_2017_09_preview/models.rs
new file mode 100644
index 0000000000..f38ce25dc5
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2017_09_preview/models.rs
@@ -0,0 +1,600 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInformation {
+    #[serde(flatten)]
+    pub job_information_basic: JobInformationBasic,
+    #[serde(rename = "errorMessage", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_message: Vec<JobErrorDetails>,
+    #[serde(rename = "stateAuditRecords", default, skip_serializing_if = "Vec::is_empty")]
+    pub state_audit_records: Vec<JobStateAuditRecord>,
+    pub properties: JobProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInformationBasic {
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: job_information_basic::Type,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub submitter: Option<String>,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<i32>,
+    #[serde(rename = "degreeOfParallelismPercent", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism_percent: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<i32>,
+    #[serde(rename = "submitTime", default, skip_serializing_if = "Option::is_none")]
+    pub submit_time: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<job_information_basic::State>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<job_information_basic::Result>,
+    #[serde(rename = "logFolder", default, skip_serializing_if = "Option::is_none")]
+    pub log_folder: Option<String>,
+    #[serde(rename = "logFilePatterns", default, skip_serializing_if = "Vec::is_empty")]
+    pub log_file_patterns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<JobRelationshipProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(rename = "hierarchyQueueNode", default, skip_serializing_if = "Option::is_none")]
+    pub hierarchy_queue_node: Option<String>,
+}
+pub mod job_information_basic {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        USql,
+        Hive,
+        Scope,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        Accepted,
+        Compiling,
+        Ended,
+        New,
+        Queued,
+        Running,
+        Scheduling,
+        Starting,
+        Paused,
+        WaitingForCapacity,
+        Yielded,
+        Finalizing,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        None,
+        Succeeded,
+        Cancelled,
+        Failed,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobProperties {
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<String>,
+    pub script: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct USqlJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<JobResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub statistics: Option<JobStatistics>,
+    #[serde(rename = "debugData", default, skip_serializing_if = "Option::is_none")]
+    pub debug_data: Option<JobDataPath>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub diagnostics: Vec<Diagnostics>,
+    #[serde(rename = "algebraFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub algebra_file_path: Option<String>,
+    #[serde(rename = "totalCompilationTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_compilation_time: Option<String>,
+    #[serde(rename = "totalQueuedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_queued_time: Option<String>,
+    #[serde(rename = "totalRunningTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_running_time: Option<String>,
+    #[serde(rename = "totalPausedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_paused_time: Option<String>,
+    #[serde(rename = "rootProcessNodeId", default, skip_serializing_if = "Option::is_none")]
+    pub root_process_node_id: Option<String>,
+    #[serde(rename = "yarnApplicationId", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_id: Option<String>,
+    #[serde(rename = "yarnApplicationTimeStamp", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_time_stamp: Option<i64>,
+    #[serde(rename = "compileMode", default, skip_serializing_if = "Option::is_none")]
+    pub compile_mode: Option<u_sql_job_properties::CompileMode>,
+}
+pub mod u_sql_job_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CompileMode {
+        Semantic,
+        Full,
+        SingleBox,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "resourcePath", default, skip_serializing_if = "Option::is_none")]
+    pub resource_path: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<job_resource::Type>,
+}
+pub mod job_resource {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        VertexResource,
+        JobManagerResource,
+        StatisticsResource,
+        VertexResourceInUserFolder,
+        JobManagerResourceInUserFolder,
+        StatisticsResourceInUserFolder,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatistics {
+    #[serde(rename = "lastUpdateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub last_update_time_utc: Option<String>,
+    #[serde(rename = "finalizingTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub finalizing_time_utc: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub stages: Vec<JobStatisticsVertexStage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatisticsVertexStage {
+    #[serde(rename = "dataRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_read: Option<i64>,
+    #[serde(rename = "dataReadCrossPod", default, skip_serializing_if = "Option::is_none")]
+    pub data_read_cross_pod: Option<i64>,
+    #[serde(rename = "dataReadIntraPod", default, skip_serializing_if = "Option::is_none")]
+    pub data_read_intra_pod: Option<i64>,
+    #[serde(rename = "dataToRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_to_read: Option<i64>,
+    #[serde(rename = "dataWritten", default, skip_serializing_if = "Option::is_none")]
+    pub data_written: Option<i64>,
+    #[serde(rename = "duplicateDiscardCount", default, skip_serializing_if = "Option::is_none")]
+    pub duplicate_discard_count: Option<i32>,
+    #[serde(rename = "failedCount", default, skip_serializing_if = "Option::is_none")]
+    pub failed_count: Option<i32>,
+    #[serde(rename = "maxVertexDataRead", default, skip_serializing_if = "Option::is_none")]
+    pub max_vertex_data_read: Option<i64>,
+    #[serde(rename = "minVertexDataRead", default, skip_serializing_if = "Option::is_none")]
+    pub min_vertex_data_read: Option<i64>,
+    #[serde(rename = "readFailureCount", default, skip_serializing_if = "Option::is_none")]
+    pub read_failure_count: Option<i32>,
+    #[serde(rename = "revocationCount", default, skip_serializing_if = "Option::is_none")]
+    pub revocation_count: Option<i32>,
+    #[serde(rename = "runningCount", default, skip_serializing_if = "Option::is_none")]
+    pub running_count: Option<i32>,
+    #[serde(rename = "scheduledCount", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_count: Option<i32>,
+    #[serde(rename = "stageName", default, skip_serializing_if = "Option::is_none")]
+    pub stage_name: Option<String>,
+    #[serde(rename = "succeededCount", default, skip_serializing_if = "Option::is_none")]
+    pub succeeded_count: Option<i32>,
+    #[serde(rename = "tempDataWritten", default, skip_serializing_if = "Option::is_none")]
+    pub temp_data_written: Option<i64>,
+    #[serde(rename = "totalCount", default, skip_serializing_if = "Option::is_none")]
+    pub total_count: Option<i32>,
+    #[serde(rename = "totalFailedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_failed_time: Option<String>,
+    #[serde(rename = "totalProgress", default, skip_serializing_if = "Option::is_none")]
+    pub total_progress: Option<i32>,
+    #[serde(rename = "totalSucceededTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_succeeded_time: Option<String>,
+    #[serde(rename = "totalPeakMemUsage", default, skip_serializing_if = "Option::is_none")]
+    pub total_peak_mem_usage: Option<i64>,
+    #[serde(rename = "totalExecutionTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_execution_time: Option<String>,
+    #[serde(rename = "maxDataReadVertex", default, skip_serializing_if = "Option::is_none")]
+    pub max_data_read_vertex: Option<JobStatisticsVertex>,
+    #[serde(rename = "maxExecutionTimeVertex", default, skip_serializing_if = "Option::is_none")]
+    pub max_execution_time_vertex: Option<JobStatisticsVertex>,
+    #[serde(rename = "maxPeakMemUsageVertex", default, skip_serializing_if = "Option::is_none")]
+    pub max_peak_mem_usage_vertex: Option<JobStatisticsVertex>,
+    #[serde(rename = "estimatedVertexCpuCoreCount", default, skip_serializing_if = "Option::is_none")]
+    pub estimated_vertex_cpu_core_count: Option<i32>,
+    #[serde(rename = "estimatedVertexPeakCpuCoreCount", default, skip_serializing_if = "Option::is_none")]
+    pub estimated_vertex_peak_cpu_core_count: Option<i32>,
+    #[serde(rename = "estimatedVertexMemSize", default, skip_serializing_if = "Option::is_none")]
+    pub estimated_vertex_mem_size: Option<i64>,
+    #[serde(rename = "allocatedContainerCpuCoreCount", default, skip_serializing_if = "Option::is_none")]
+    pub allocated_container_cpu_core_count: Option<ResourceUsageStatistics>,
+    #[serde(rename = "allocatedContainerMemSize", default, skip_serializing_if = "Option::is_none")]
+    pub allocated_container_mem_size: Option<ResourceUsageStatistics>,
+    #[serde(rename = "usedVertexCpuCoreCount", default, skip_serializing_if = "Option::is_none")]
+    pub used_vertex_cpu_core_count: Option<ResourceUsageStatistics>,
+    #[serde(rename = "usedVertexPeakMemSize", default, skip_serializing_if = "Option::is_none")]
+    pub used_vertex_peak_mem_size: Option<ResourceUsageStatistics>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStatisticsVertex {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "vertexId", default, skip_serializing_if = "Option::is_none")]
+    pub vertex_id: Option<String>,
+    #[serde(rename = "executionTime", default, skip_serializing_if = "Option::is_none")]
+    pub execution_time: Option<String>,
+    #[serde(rename = "dataRead", default, skip_serializing_if = "Option::is_none")]
+    pub data_read: Option<i64>,
+    #[serde(rename = "peakMemUsage", default, skip_serializing_if = "Option::is_none")]
+    pub peak_mem_usage: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceUsageStatistics {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub average: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub minimum: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub maximum: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDataPath {
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub command: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub paths: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Diagnostics {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<diagnostics::Severity>,
+    #[serde(rename = "lineNumber", default, skip_serializing_if = "Option::is_none")]
+    pub line_number: Option<i32>,
+    #[serde(rename = "columnNumber", default, skip_serializing_if = "Option::is_none")]
+    pub column_number: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub end: Option<i32>,
+}
+pub mod diagnostics {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+        SevereWarning,
+        Deprecated,
+        UserWarning,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(rename = "logsLocation", default, skip_serializing_if = "Option::is_none")]
+    pub logs_location: Option<String>,
+    #[serde(rename = "outputLocation", default, skip_serializing_if = "Option::is_none")]
+    pub output_location: Option<String>,
+    #[serde(rename = "statementCount", default, skip_serializing_if = "Option::is_none")]
+    pub statement_count: Option<i32>,
+    #[serde(rename = "executedStatementCount", default, skip_serializing_if = "Option::is_none")]
+    pub executed_statement_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScopeJobProperties {
+    #[serde(flatten)]
+    pub job_properties: JobProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<ScopeJobResource>,
+    #[serde(rename = "userAlgebraPath", default, skip_serializing_if = "Option::is_none")]
+    pub user_algebra_path: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub notifier: Option<String>,
+    #[serde(rename = "totalCompilationTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_compilation_time: Option<String>,
+    #[serde(rename = "totalQueuedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_queued_time: Option<String>,
+    #[serde(rename = "totalRunningTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_running_time: Option<String>,
+    #[serde(rename = "totalPausedTime", default, skip_serializing_if = "Option::is_none")]
+    pub total_paused_time: Option<String>,
+    #[serde(rename = "rootProcessNodeId", default, skip_serializing_if = "Option::is_none")]
+    pub root_process_node_id: Option<String>,
+    #[serde(rename = "yarnApplicationId", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_application_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScopeJobResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobRelationshipProperties {
+    #[serde(rename = "pipelineId", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_id: Option<String>,
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(rename = "pipelineUri", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_uri: Option<String>,
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "recurrenceId")]
+    pub recurrence_id: String,
+    #[serde(rename = "recurrenceName", default, skip_serializing_if = "Option::is_none")]
+    pub recurrence_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobErrorDetails {
+    #[serde(rename = "errorId", default, skip_serializing_if = "Option::is_none")]
+    pub error_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<job_error_details::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+    #[serde(rename = "lineNumber", default, skip_serializing_if = "Option::is_none")]
+    pub line_number: Option<i32>,
+    #[serde(rename = "startOffset", default, skip_serializing_if = "Option::is_none")]
+    pub start_offset: Option<i32>,
+    #[serde(rename = "endOffset", default, skip_serializing_if = "Option::is_none")]
+    pub end_offset: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolution: Option<String>,
+    #[serde(rename = "filePath", default, skip_serializing_if = "Option::is_none")]
+    pub file_path: Option<String>,
+    #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
+    pub help_link: Option<String>,
+    #[serde(rename = "internalDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub internal_diagnostics: Option<String>,
+    #[serde(rename = "innerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Option<JobInnerError>,
+}
+pub mod job_error_details {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+        SevereWarning,
+        Deprecated,
+        UserWarning,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInnerError {
+    #[serde(rename = "errorId", default, skip_serializing_if = "Option::is_none")]
+    pub error_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub severity: Option<job_inner_error::Severity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+    #[serde(rename = "diagnosticCode", default, skip_serializing_if = "Option::is_none")]
+    pub diagnostic_code: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub component: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resolution: Option<String>,
+    #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
+    pub help_link: Option<String>,
+    #[serde(rename = "internalDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub internal_diagnostics: Option<String>,
+    #[serde(rename = "innerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Option<JobInnerError>,
+}
+pub mod job_inner_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Severity {
+        Warning,
+        Error,
+        Info,
+        SevereWarning,
+        Deprecated,
+        UserWarning,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobStateAuditRecord {
+    #[serde(rename = "newState", default, skip_serializing_if = "Option::is_none")]
+    pub new_state: Option<String>,
+    #[serde(rename = "timeStamp", default, skip_serializing_if = "Option::is_none")]
+    pub time_stamp: Option<String>,
+    #[serde(rename = "requestedByUser", default, skip_serializing_if = "Option::is_none")]
+    pub requested_by_user: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub details: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobInfoListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobInformationBasic>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobPipelineInformation {
+    #[serde(rename = "pipelineId", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_id: Option<String>,
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(rename = "pipelineUri", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_uri: Option<String>,
+    #[serde(rename = "numJobsFailed", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_failed: Option<i32>,
+    #[serde(rename = "numJobsCanceled", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_canceled: Option<i32>,
+    #[serde(rename = "numJobsSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_succeeded: Option<i32>,
+    #[serde(rename = "auHoursFailed", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_failed: Option<f64>,
+    #[serde(rename = "auHoursCanceled", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_canceled: Option<f64>,
+    #[serde(rename = "auHoursSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_succeeded: Option<f64>,
+    #[serde(rename = "lastSubmitTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_submit_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub runs: Vec<JobPipelineRunInformation>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub recurrences: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobPipelineRunInformation {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "lastSubmitTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_submit_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobPipelineInformationListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobPipelineInformation>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobRecurrenceInformation {
+    #[serde(rename = "recurrenceId", default, skip_serializing_if = "Option::is_none")]
+    pub recurrence_id: Option<String>,
+    #[serde(rename = "recurrenceName", default, skip_serializing_if = "Option::is_none")]
+    pub recurrence_name: Option<String>,
+    #[serde(rename = "numJobsFailed", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_failed: Option<i32>,
+    #[serde(rename = "numJobsCanceled", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_canceled: Option<i32>,
+    #[serde(rename = "numJobsSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub num_jobs_succeeded: Option<i32>,
+    #[serde(rename = "auHoursFailed", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_failed: Option<f64>,
+    #[serde(rename = "auHoursCanceled", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_canceled: Option<f64>,
+    #[serde(rename = "auHoursSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub au_hours_succeeded: Option<f64>,
+    #[serde(rename = "lastSubmitTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_submit_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobRecurrenceInformationListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobRecurrenceInformation>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BaseJobParameters {
+    #[serde(rename = "type")]
+    pub type_: base_job_parameters::Type,
+    pub properties: CreateJobProperties,
+}
+pub mod base_job_parameters {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        USql,
+        Hive,
+        Scope,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateJobParameters {
+    #[serde(flatten)]
+    pub base_job_parameters: BaseJobParameters,
+    pub name: String,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<i32>,
+    #[serde(rename = "degreeOfParallelismPercent", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism_percent: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<i32>,
+    #[serde(rename = "logFilePatterns", default, skip_serializing_if = "Vec::is_empty")]
+    pub log_file_patterns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<JobRelationshipProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateScopeJobParameters {
+    #[serde(flatten)]
+    pub create_job_parameters: CreateJobParameters,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateJobProperties {
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<String>,
+    pub script: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateUSqlJobProperties {
+    #[serde(flatten)]
+    pub create_job_properties: CreateJobProperties,
+    #[serde(rename = "compileMode", default, skip_serializing_if = "Option::is_none")]
+    pub compile_mode: Option<create_u_sql_job_properties::CompileMode>,
+}
+pub mod create_u_sql_job_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CompileMode {
+        Semantic,
+        Full,
+        SingleBox,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateScopeJobProperties {
+    #[serde(flatten)]
+    pub create_job_properties: CreateJobProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<ScopeJobResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub notifier: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BuildJobParameters {
+    #[serde(flatten)]
+    pub base_job_parameters: BaseJobParameters,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UpdateJobParameters {
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<i32>,
+    #[serde(rename = "degreeOfParallelismPercent", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism_percent: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+}
diff --git a/services/svc/datalake_analytics/src/package_job_2017_09_preview/operations.rs b/services/svc/datalake_analytics/src/package_job_2017_09_preview/operations.rs
new file mode 100644
index 0000000000..6d450a0c18
--- /dev/null
+++ b/services/svc/datalake_analytics/src/package_job_2017_09_preview/operations.rs
@@ -0,0 +1,833 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod job {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        top: Option<i32>,
+        skip: Option<i32>,
+        select: Option<&str>,
+        orderby: Option<&str>,
+        count: Option<bool>,
+    ) -> std::result::Result<JobInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("$skip", skip.to_string().as_str());
+        }
+        if let Some(select) = select {
+            url.query_pairs_mut().append_pair("$select", select);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(count) = count {
+            url.query_pairs_mut().append_pair("$count", count.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, job_identity: &str) -> std::result::Result<JobInformation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+        parameters: &CreateJobParameters,
+    ) -> std::result::Result<JobInformation, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+        parameters: Option<&UpdateJobParameters>,
+    ) -> std::result::Result<update::Response, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = if let Some(parameters) = parameters {
+            azure_core::to_json(parameters).map_err(update::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(update::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => Ok(update::Response::Created201),
+            http::StatusCode::ACCEPTED => Ok(update::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(JobInformation),
+            Created201,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_statistics(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<JobStatistics, get_statistics::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/GetStatistics", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get_statistics::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_statistics::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_statistics::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_statistics::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobStatistics =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_statistics::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_statistics::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_statistics {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_debug_data_path(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<JobDataPath, get_debug_data_path::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/GetDebugDataPath", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(get_debug_data_path::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_debug_data_path::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_debug_data_path::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_debug_data_path::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDataPath = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_debug_data_path::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_debug_data_path::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_debug_data_path {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<cancel::Response, cancel::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/CancelJob", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(cancel::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(cancel::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(cancel::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(cancel::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn yield_(
+        operation_config: &crate::OperationConfig,
+        job_identity: &str,
+    ) -> std::result::Result<yield_::Response, yield_::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/YieldJob", operation_config.base_path(), job_identity);
+        let mut url = url::Url::parse(url_str).map_err(yield_::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(yield_::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(yield_::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(yield_::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(yield_::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(yield_::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(yield_::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(yield_::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod yield_ {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn build(
+        operation_config: &crate::OperationConfig,
+        parameters: &BuildJobParameters,
+    ) -> std::result::Result<JobInformation, build::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/buildJob", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(build::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(build::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(build::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(build::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(build::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| build::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(build::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod build {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        start_date_time: Option<&str>,
+        end_date_time: Option<&str>,
+    ) -> std::result::Result<JobPipelineInformationListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(start_date_time) = start_date_time {
+            url.query_pairs_mut().append_pair("startDateTime", start_date_time);
+        }
+        if let Some(end_date_time) = end_date_time {
+            url.query_pairs_mut().append_pair("endDateTime", end_date_time);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobPipelineInformationListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        pipeline_identity: &str,
+        start_date_time: Option<&str>,
+        end_date_time: Option<&str>,
+    ) -> std::result::Result<JobPipelineInformation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_identity);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(start_date_time) = start_date_time {
+            url.query_pairs_mut().append_pair("startDateTime", start_date_time);
+        }
+        if let Some(end_date_time) = end_date_time {
+            url.query_pairs_mut().append_pair("endDateTime", end_date_time);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobPipelineInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod recurrence {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        start_date_time: Option<&str>,
+        end_date_time: Option<&str>,
+    ) -> std::result::Result<JobRecurrenceInformationListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/recurrences", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(start_date_time) = start_date_time {
+            url.query_pairs_mut().append_pair("startDateTime", start_date_time);
+        }
+        if let Some(end_date_time) = end_date_time {
+            url.query_pairs_mut().append_pair("endDateTime", end_date_time);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobRecurrenceInformationListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        recurrence_identity: &str,
+        start_date_time: Option<&str>,
+        end_date_time: Option<&str>,
+    ) -> std::result::Result<JobRecurrenceInformation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/recurrences/{}", operation_config.base_path(), recurrence_identity);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(start_date_time) = start_date_time {
+            url.query_pairs_mut().append_pair("startDateTime", start_date_time);
+        }
+        if let Some(end_date_time) = end_date_time {
+            url.query_pairs_mut().append_pair("endDateTime", end_date_time);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobRecurrenceInformation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/datalake_store/Cargo.toml b/services/svc/datalake_store/Cargo.toml
new file mode 100644
index 0000000000..65d617169a
--- /dev/null
+++ b/services/svc/datalake_store/Cargo.toml
@@ -0,0 +1,24 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_datalake_store"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2016-11"]
+"package-2016-11" = []
+"package-2015-10-preview" = []
diff --git a/services/svc/datalake_store/src/lib.rs b/services/svc/datalake_store/src/lib.rs
new file mode 100644
index 0000000000..5e465ebd5c
--- /dev/null
+++ b/services/svc/datalake_store/src/lib.rs
@@ -0,0 +1,65 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2016-11")]
+mod package_2016_11;
+#[cfg(feature = "package-2016-11")]
+pub use package_2016_11::{models, operations, API_VERSION};
+#[cfg(feature = "package-2015-10-preview")]
+mod package_2015_10_preview;
+use azure_core::setters;
+#[cfg(feature = "package-2015-10-preview")]
+pub use package_2015_10_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/datalake_store/src/package_2015_10_preview/mod.rs b/services/svc/datalake_store/src/package_2015_10_preview/mod.rs
new file mode 100644
index 0000000000..da17bb56ce
--- /dev/null
+++ b/services/svc/datalake_store/src/package_2015_10_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2015-10-01-preview";
diff --git a/services/svc/datalake_store/src/package_2015_10_preview/models.rs b/services/svc/datalake_store/src/package_2015_10_preview/models.rs
new file mode 100644
index 0000000000..8d26b02270
--- /dev/null
+++ b/services/svc/datalake_store/src/package_2015_10_preview/models.rs
@@ -0,0 +1,151 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileOperationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub boolean: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AclStatus {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub entries: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub owner: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub permission: Option<i32>,
+    #[serde(rename = "stickyBit", default, skip_serializing_if = "Option::is_none")]
+    pub sticky_bit: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AclStatusResult {
+    #[serde(rename = "AclStatus", default, skip_serializing_if = "Option::is_none")]
+    pub acl_status: Option<AclStatus>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContentSummary {
+    #[serde(rename = "directoryCount", default, skip_serializing_if = "Option::is_none")]
+    pub directory_count: Option<i64>,
+    #[serde(rename = "fileCount", default, skip_serializing_if = "Option::is_none")]
+    pub file_count: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub length: Option<i64>,
+    #[serde(rename = "spaceConsumed", default, skip_serializing_if = "Option::is_none")]
+    pub space_consumed: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContentSummaryResult {
+    #[serde(rename = "ContentSummary", default, skip_serializing_if = "Option::is_none")]
+    pub content_summary: Option<ContentSummary>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileStatusProperties {
+    #[serde(rename = "accessTime", default, skip_serializing_if = "Option::is_none")]
+    pub access_time: Option<i64>,
+    #[serde(rename = "blockSize", default, skip_serializing_if = "Option::is_none")]
+    pub block_size: Option<i64>,
+    #[serde(rename = "childrenNum", default, skip_serializing_if = "Option::is_none")]
+    pub children_num: Option<i64>,
+    #[serde(rename = "expirationTime", default, skip_serializing_if = "Option::is_none")]
+    pub expiration_time: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub length: Option<i64>,
+    #[serde(rename = "modificationTime", default, skip_serializing_if = "Option::is_none")]
+    pub modification_time: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub owner: Option<String>,
+    #[serde(rename = "pathSuffix", default, skip_serializing_if = "Option::is_none")]
+    pub path_suffix: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub permission: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<file_status_properties::Type>,
+}
+pub mod file_status_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "FILE")]
+        File,
+        #[serde(rename = "DIRECTORY")]
+        Directory,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileStatuses {
+    #[serde(rename = "FileStatus", default, skip_serializing_if = "Vec::is_empty")]
+    pub file_status: Vec<FileStatusProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileStatusesResult {
+    #[serde(rename = "FileStatuses", default, skip_serializing_if = "Option::is_none")]
+    pub file_statuses: Option<FileStatuses>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileStatusResult {
+    #[serde(rename = "FileStatus", default, skip_serializing_if = "Option::is_none")]
+    pub file_status: Option<FileStatusProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsIllegalArgumentException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsUnsupportedOperationException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsSecurityException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsIoException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsFileNotFoundException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsFileAlreadyExistsException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsBadOffsetException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsRuntimeException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsAccessControlException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsRemoteException {
+    pub exception: String,
+    #[serde(rename = "javaClassName", default, skip_serializing_if = "Option::is_none")]
+    pub java_class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsError {
+    #[serde(rename = "RemoteException", default, skip_serializing_if = "Option::is_none")]
+    pub remote_exception: Option<AdlsRemoteException>,
+}
diff --git a/services/svc/datalake_store/src/package_2015_10_preview/operations.rs b/services/svc/datalake_store/src/package_2015_10_preview/operations.rs
new file mode 100644
index 0000000000..233c91dbed
--- /dev/null
+++ b/services/svc/datalake_store/src/package_2015_10_preview/operations.rs
@@ -0,0 +1,275 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod file_system {
+    use crate::models::*;
+    pub async fn concurrent_append(
+        operation_config: &crate::OperationConfig,
+        file_path: &str,
+        stream_contents: &serde_json::Value,
+        append_mode: Option<&str>,
+        op: &str,
+        transfer_encoding: &str,
+    ) -> std::result::Result<(), concurrent_append::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/WebHdfsExt/{}", operation_config.base_path(), file_path);
+        let mut url = url::Url::parse(url_str).map_err(concurrent_append::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(concurrent_append::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(stream_contents).map_err(concurrent_append::Error::SerializeError)?;
+        if let Some(append_mode) = append_mode {
+            url.query_pairs_mut().append_pair("appendMode", append_mode);
+        }
+        url.query_pairs_mut().append_pair("op", op);
+        req_builder = req_builder.header("Transfer-Encoding", transfer_encoding);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(concurrent_append::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(concurrent_append::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdlsError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| concurrent_append::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(concurrent_append::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod concurrent_append {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::AdlsError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn set_file_expiry(
+        operation_config: &crate::OperationConfig,
+        file_path: &str,
+        expiry_option: &str,
+        expire_time: Option<i64>,
+        op: &str,
+    ) -> std::result::Result<(), set_file_expiry::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/WebHdfsExt/{}", operation_config.base_path(), file_path);
+        let mut url = url::Url::parse(url_str).map_err(set_file_expiry::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(set_file_expiry::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        url.query_pairs_mut().append_pair("expiryOption", expiry_option);
+        if let Some(expire_time) = expire_time {
+            url.query_pairs_mut().append_pair("expireTime", expire_time.to_string().as_str());
+        }
+        url.query_pairs_mut().append_pair("op", op);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(set_file_expiry::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(set_file_expiry::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdlsError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| set_file_expiry::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(set_file_expiry::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod set_file_expiry {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::AdlsError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn check_access(
+        operation_config: &crate::OperationConfig,
+        path: &str,
+        fsaction: Option<&str>,
+        op: &str,
+    ) -> std::result::Result<(), check_access::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/webhdfs/v1/{}", operation_config.base_path(), path);
+        let mut url = url::Url::parse(url_str).map_err(check_access::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(check_access::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(fsaction) = fsaction {
+            url.query_pairs_mut().append_pair("fsaction", fsaction);
+        }
+        url.query_pairs_mut().append_pair("op", op);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(check_access::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(check_access::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdlsError =
+                    serde_json::from_slice(rsp_body).map_err(|source| check_access::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(check_access::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod check_access {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::AdlsError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn mkdirs(
+        operation_config: &crate::OperationConfig,
+        path: &str,
+        op: &str,
+    ) -> std::result::Result<FileOperationResult, mkdirs::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/webhdfs/v1/{}", operation_config.base_path(), path);
+        let mut url = url::Url::parse(url_str).map_err(mkdirs::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(mkdirs::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        url.query_pairs_mut().append_pair("op", op);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(mkdirs::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(mkdirs::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: FileOperationResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| mkdirs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdlsError =
+                    serde_json::from_slice(rsp_body).map_err(|source| mkdirs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(mkdirs::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod mkdirs {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::AdlsError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/datalake_store/src/package_2016_11/mod.rs b/services/svc/datalake_store/src/package_2016_11/mod.rs
new file mode 100644
index 0000000000..6892af8bdd
--- /dev/null
+++ b/services/svc/datalake_store/src/package_2016_11/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2016-11-01";
diff --git a/services/svc/datalake_store/src/package_2016_11/models.rs b/services/svc/datalake_store/src/package_2016_11/models.rs
new file mode 100644
index 0000000000..b31570a38b
--- /dev/null
+++ b/services/svc/datalake_store/src/package_2016_11/models.rs
@@ -0,0 +1,156 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileOperationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub boolean: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AclStatus {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub entries: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub owner: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub permission: Option<String>,
+    #[serde(rename = "stickyBit", default, skip_serializing_if = "Option::is_none")]
+    pub sticky_bit: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AclStatusResult {
+    #[serde(rename = "aclStatus", default, skip_serializing_if = "Option::is_none")]
+    pub acl_status: Option<AclStatus>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContentSummary {
+    #[serde(rename = "directoryCount", default, skip_serializing_if = "Option::is_none")]
+    pub directory_count: Option<i64>,
+    #[serde(rename = "fileCount", default, skip_serializing_if = "Option::is_none")]
+    pub file_count: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub length: Option<i64>,
+    #[serde(rename = "spaceConsumed", default, skip_serializing_if = "Option::is_none")]
+    pub space_consumed: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContentSummaryResult {
+    #[serde(rename = "contentSummary", default, skip_serializing_if = "Option::is_none")]
+    pub content_summary: Option<ContentSummary>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileStatusProperties {
+    #[serde(rename = "accessTime", default, skip_serializing_if = "Option::is_none")]
+    pub access_time: Option<i64>,
+    #[serde(rename = "blockSize", default, skip_serializing_if = "Option::is_none")]
+    pub block_size: Option<i64>,
+    #[serde(rename = "msExpirationTime", default, skip_serializing_if = "Option::is_none")]
+    pub ms_expiration_time: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub group: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub length: Option<i64>,
+    #[serde(rename = "modificationTime", default, skip_serializing_if = "Option::is_none")]
+    pub modification_time: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub owner: Option<String>,
+    #[serde(rename = "pathSuffix", default, skip_serializing_if = "Option::is_none")]
+    pub path_suffix: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub permission: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<file_status_properties::Type>,
+    #[serde(rename = "aclBit", default, skip_serializing_if = "Option::is_none")]
+    pub acl_bit: Option<bool>,
+}
+pub mod file_status_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "FILE")]
+        File,
+        #[serde(rename = "DIRECTORY")]
+        Directory,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileStatuses {
+    #[serde(rename = "fileStatus", default, skip_serializing_if = "Vec::is_empty")]
+    pub file_status: Vec<FileStatusProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileStatusesResult {
+    #[serde(rename = "fileStatuses", default, skip_serializing_if = "Option::is_none")]
+    pub file_statuses: Option<FileStatuses>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileStatusResult {
+    #[serde(rename = "fileStatus", default, skip_serializing_if = "Option::is_none")]
+    pub file_status: Option<FileStatusProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsIllegalArgumentException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsUnsupportedOperationException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsSecurityException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsIoException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsFileNotFoundException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsFileAlreadyExistsException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsBadOffsetException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsRuntimeException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsAccessControlException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsThrottledException {
+    #[serde(flatten)]
+    pub adls_remote_exception: AdlsRemoteException,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsRemoteException {
+    pub exception: String,
+    #[serde(rename = "javaClassName", default, skip_serializing_if = "Option::is_none")]
+    pub java_class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsError {
+    #[serde(rename = "remoteException", default, skip_serializing_if = "Option::is_none")]
+    pub remote_exception: Option<AdlsRemoteException>,
+}
diff --git a/services/svc/datalake_store/src/package_2016_11/operations.rs b/services/svc/datalake_store/src/package_2016_11/operations.rs
new file mode 100644
index 0000000000..266ad39010
--- /dev/null
+++ b/services/svc/datalake_store/src/package_2016_11/operations.rs
@@ -0,0 +1,213 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod file_system {
+    use crate::models::*;
+    pub async fn concurrent_append(
+        operation_config: &crate::OperationConfig,
+        path: &str,
+        stream_contents: &serde_json::Value,
+        append_mode: Option<&str>,
+        op: &str,
+        transfer_encoding: &str,
+        sync_flag: Option<&str>,
+    ) -> std::result::Result<(), concurrent_append::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/WebHdfsExt/{}", operation_config.base_path(), path);
+        let mut url = url::Url::parse(url_str).map_err(concurrent_append::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(concurrent_append::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(stream_contents).map_err(concurrent_append::Error::SerializeError)?;
+        if let Some(append_mode) = append_mode {
+            url.query_pairs_mut().append_pair("appendMode", append_mode);
+        }
+        url.query_pairs_mut().append_pair("op", op);
+        req_builder = req_builder.header("Transfer-Encoding", transfer_encoding);
+        if let Some(sync_flag) = sync_flag {
+            url.query_pairs_mut().append_pair("syncFlag", sync_flag);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(concurrent_append::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(concurrent_append::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdlsError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| concurrent_append::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(concurrent_append::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod concurrent_append {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::AdlsError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn set_file_expiry(
+        operation_config: &crate::OperationConfig,
+        path: &str,
+        expiry_option: &str,
+        expire_time: Option<i64>,
+        op: &str,
+    ) -> std::result::Result<(), set_file_expiry::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/WebHdfsExt/{}", operation_config.base_path(), path);
+        let mut url = url::Url::parse(url_str).map_err(set_file_expiry::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(set_file_expiry::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        url.query_pairs_mut().append_pair("expiryOption", expiry_option);
+        if let Some(expire_time) = expire_time {
+            url.query_pairs_mut().append_pair("expireTime", expire_time.to_string().as_str());
+        }
+        url.query_pairs_mut().append_pair("op", op);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(set_file_expiry::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(set_file_expiry::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdlsError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| set_file_expiry::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(set_file_expiry::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod set_file_expiry {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::AdlsError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn check_access(
+        operation_config: &crate::OperationConfig,
+        path: &str,
+        fsaction: &str,
+        op: &str,
+    ) -> std::result::Result<(), check_access::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/webhdfs/v1/{}", operation_config.base_path(), path);
+        let mut url = url::Url::parse(url_str).map_err(check_access::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(check_access::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        url.query_pairs_mut().append_pair("fsaction", fsaction);
+        url.query_pairs_mut().append_pair("op", op);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(check_access::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(check_access::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdlsError =
+                    serde_json::from_slice(rsp_body).map_err(|source| check_access::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(check_access::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod check_access {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::AdlsError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/deviceprovisioningservices/Cargo.toml b/services/svc/deviceprovisioningservices/Cargo.toml
new file mode 100644
index 0000000000..7e4dc102d0
--- /dev/null
+++ b/services/svc/deviceprovisioningservices/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_deviceprovisioningservices"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2021-10-01"]
+"package-2021-10-01" = []
diff --git a/services/svc/deviceprovisioningservices/src/lib.rs b/services/svc/deviceprovisioningservices/src/lib.rs
new file mode 100644
index 0000000000..4a608af7bf
--- /dev/null
+++ b/services/svc/deviceprovisioningservices/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2021-10-01")]
+mod package_2021_10_01;
+use azure_core::setters;
+#[cfg(feature = "package-2021-10-01")]
+pub use package_2021_10_01::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/deviceprovisioningservices/src/package_2021_10_01/mod.rs b/services/svc/deviceprovisioningservices/src/package_2021_10_01/mod.rs
new file mode 100644
index 0000000000..5b44179ff5
--- /dev/null
+++ b/services/svc/deviceprovisioningservices/src/package_2021_10_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-10-01";
diff --git a/services/svc/deviceprovisioningservices/src/package_2021_10_01/models.rs b/services/svc/deviceprovisioningservices/src/package_2021_10_01/models.rs
new file mode 100644
index 0000000000..d1242205af
--- /dev/null
+++ b/services/svc/deviceprovisioningservices/src/package_2021_10_01/models.rs
@@ -0,0 +1,382 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProvisioningServiceErrorDetails {
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<i32>,
+    #[serde(rename = "trackingId", default, skip_serializing_if = "Option::is_none")]
+    pub tracking_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<serde_json::Value>,
+    #[serde(rename = "timestampUtc", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_utc: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IndividualEnrollment {
+    #[serde(rename = "registrationId")]
+    pub registration_id: String,
+    #[serde(rename = "deviceId", default, skip_serializing_if = "Option::is_none")]
+    pub device_id: Option<String>,
+    #[serde(rename = "registrationState", default, skip_serializing_if = "Option::is_none")]
+    pub registration_state: Option<DeviceRegistrationState>,
+    #[serde(rename = "optionalDeviceInformation", default, skip_serializing_if = "Option::is_none")]
+    pub optional_device_information: Option<TwinCollection>,
+    pub attestation: AttestationMechanism,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub capabilities: Option<DeviceCapabilities>,
+    #[serde(rename = "iotHubHostName", default, skip_serializing_if = "Option::is_none")]
+    pub iot_hub_host_name: Option<String>,
+    #[serde(rename = "initialTwin", default, skip_serializing_if = "Option::is_none")]
+    pub initial_twin: Option<InitialTwin>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<individual_enrollment::ProvisioningStatus>,
+    #[serde(rename = "reprovisionPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub reprovision_policy: Option<ReprovisionPolicy>,
+    #[serde(rename = "createdDateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub created_date_time_utc: Option<String>,
+    #[serde(rename = "lastUpdatedDateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated_date_time_utc: Option<String>,
+    #[serde(rename = "allocationPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub allocation_policy: Option<individual_enrollment::AllocationPolicy>,
+    #[serde(rename = "iotHubs", default, skip_serializing_if = "Vec::is_empty")]
+    pub iot_hubs: Vec<String>,
+    #[serde(rename = "customAllocationDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub custom_allocation_definition: Option<CustomAllocationDefinition>,
+}
+pub mod individual_enrollment {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ProvisioningStatus {
+        #[serde(rename = "enabled")]
+        Enabled,
+        #[serde(rename = "disabled")]
+        Disabled,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AllocationPolicy {
+        #[serde(rename = "hashed")]
+        Hashed,
+        #[serde(rename = "geoLatency")]
+        GeoLatency,
+        #[serde(rename = "static")]
+        Static,
+        #[serde(rename = "custom")]
+        Custom,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceRegistrationState {
+    #[serde(rename = "registrationId", default, skip_serializing_if = "Option::is_none")]
+    pub registration_id: Option<String>,
+    #[serde(rename = "createdDateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub created_date_time_utc: Option<String>,
+    #[serde(rename = "assignedHub", default, skip_serializing_if = "Option::is_none")]
+    pub assigned_hub: Option<String>,
+    #[serde(rename = "deviceId", default, skip_serializing_if = "Option::is_none")]
+    pub device_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<device_registration_state::Status>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub substatus: Option<device_registration_state::Substatus>,
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<i32>,
+    #[serde(rename = "errorMessage", default, skip_serializing_if = "Option::is_none")]
+    pub error_message: Option<String>,
+    #[serde(rename = "lastUpdatedDateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated_date_time_utc: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub payload: Option<serde_json::Value>,
+}
+pub mod device_registration_state {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        #[serde(rename = "unassigned")]
+        Unassigned,
+        #[serde(rename = "assigning")]
+        Assigning,
+        #[serde(rename = "assigned")]
+        Assigned,
+        #[serde(rename = "failed")]
+        Failed,
+        #[serde(rename = "disabled")]
+        Disabled,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Substatus {
+        #[serde(rename = "initialAssignment")]
+        InitialAssignment,
+        #[serde(rename = "deviceDataMigrated")]
+        DeviceDataMigrated,
+        #[serde(rename = "deviceDataReset")]
+        DeviceDataReset,
+        #[serde(rename = "reprovisionedToInitialAssignment")]
+        ReprovisionedToInitialAssignment,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestationMechanism {
+    #[serde(rename = "type")]
+    pub type_: attestation_mechanism::Type,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tpm: Option<TpmAttestation>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub x509: Option<X509Attestation>,
+    #[serde(rename = "symmetricKey", default, skip_serializing_if = "Option::is_none")]
+    pub symmetric_key: Option<SymmetricKeyAttestation>,
+}
+pub mod attestation_mechanism {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "none")]
+        None,
+        #[serde(rename = "tpm")]
+        Tpm,
+        #[serde(rename = "x509")]
+        X509,
+        #[serde(rename = "symmetricKey")]
+        SymmetricKey,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCapabilities {
+    #[serde(rename = "iotEdge")]
+    pub iot_edge: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InitialTwin {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<TwinCollection>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<InitialTwinProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ReprovisionPolicy {
+    #[serde(rename = "updateHubAssignment")]
+    pub update_hub_assignment: bool,
+    #[serde(rename = "migrateDeviceData")]
+    pub migrate_device_data: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomAllocationDefinition {
+    #[serde(rename = "webhookUrl")]
+    pub webhook_url: String,
+    #[serde(rename = "apiVersion")]
+    pub api_version: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TpmAttestation {
+    #[serde(rename = "endorsementKey")]
+    pub endorsement_key: String,
+    #[serde(rename = "storageRootKey", default, skip_serializing_if = "Option::is_none")]
+    pub storage_root_key: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Attestation {
+    #[serde(rename = "clientCertificates", default, skip_serializing_if = "Option::is_none")]
+    pub client_certificates: Option<X509Certificates>,
+    #[serde(rename = "signingCertificates", default, skip_serializing_if = "Option::is_none")]
+    pub signing_certificates: Option<X509Certificates>,
+    #[serde(rename = "caReferences", default, skip_serializing_if = "Option::is_none")]
+    pub ca_references: Option<X509caReferences>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SymmetricKeyAttestation {
+    #[serde(rename = "primaryKey", default, skip_serializing_if = "Option::is_none")]
+    pub primary_key: Option<String>,
+    #[serde(rename = "secondaryKey", default, skip_serializing_if = "Option::is_none")]
+    pub secondary_key: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InitialTwinProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub desired: Option<TwinCollection>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Certificates {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub primary: Option<X509CertificateWithInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub secondary: Option<X509CertificateWithInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509caReferences {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub primary: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub secondary: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509CertificateWithInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub certificate: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<X509CertificateInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509CertificateInfo {
+    #[serde(rename = "subjectName")]
+    pub subject_name: String,
+    #[serde(rename = "sha1Thumbprint")]
+    pub sha1_thumbprint: String,
+    #[serde(rename = "sha256Thumbprint")]
+    pub sha256_thumbprint: String,
+    #[serde(rename = "issuerName")]
+    pub issuer_name: String,
+    #[serde(rename = "notBeforeUtc")]
+    pub not_before_utc: String,
+    #[serde(rename = "notAfterUtc")]
+    pub not_after_utc: String,
+    #[serde(rename = "serialNumber")]
+    pub serial_number: String,
+    pub version: i32,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EnrollmentGroup {
+    #[serde(rename = "enrollmentGroupId")]
+    pub enrollment_group_id: String,
+    pub attestation: AttestationMechanism,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub capabilities: Option<DeviceCapabilities>,
+    #[serde(rename = "iotHubHostName", default, skip_serializing_if = "Option::is_none")]
+    pub iot_hub_host_name: Option<String>,
+    #[serde(rename = "initialTwin", default, skip_serializing_if = "Option::is_none")]
+    pub initial_twin: Option<InitialTwin>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<enrollment_group::ProvisioningStatus>,
+    #[serde(rename = "reprovisionPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub reprovision_policy: Option<ReprovisionPolicy>,
+    #[serde(rename = "createdDateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub created_date_time_utc: Option<String>,
+    #[serde(rename = "lastUpdatedDateTimeUtc", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated_date_time_utc: Option<String>,
+    #[serde(rename = "allocationPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub allocation_policy: Option<enrollment_group::AllocationPolicy>,
+    #[serde(rename = "iotHubs", default, skip_serializing_if = "Vec::is_empty")]
+    pub iot_hubs: Vec<String>,
+    #[serde(rename = "customAllocationDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub custom_allocation_definition: Option<CustomAllocationDefinition>,
+}
+pub mod enrollment_group {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ProvisioningStatus {
+        #[serde(rename = "enabled")]
+        Enabled,
+        #[serde(rename = "disabled")]
+        Disabled,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AllocationPolicy {
+        #[serde(rename = "hashed")]
+        Hashed,
+        #[serde(rename = "geoLatency")]
+        GeoLatency,
+        #[serde(rename = "static")]
+        Static,
+        #[serde(rename = "custom")]
+        Custom,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuerySpecification {
+    pub query: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BulkEnrollmentOperation {
+    pub enrollments: Vec<IndividualEnrollment>,
+    pub mode: bulk_enrollment_operation::Mode,
+}
+pub mod bulk_enrollment_operation {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Mode {
+        #[serde(rename = "create")]
+        Create,
+        #[serde(rename = "update")]
+        Update,
+        #[serde(rename = "updateIfMatchETag")]
+        UpdateIfMatchETag,
+        #[serde(rename = "delete")]
+        Delete,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BulkEnrollmentOperationResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub errors: Vec<BulkEnrollmentOperationError>,
+    #[serde(rename = "isSuccessful")]
+    pub is_successful: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BulkEnrollmentOperationError {
+    #[serde(rename = "registrationId")]
+    pub registration_id: String,
+    #[serde(rename = "errorCode")]
+    pub error_code: i32,
+    #[serde(rename = "errorStatus")]
+    pub error_status: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BulkEnrollmentGroupOperation {
+    #[serde(rename = "enrollmentGroups")]
+    pub enrollment_groups: Vec<EnrollmentGroup>,
+    pub mode: bulk_enrollment_group_operation::Mode,
+}
+pub mod bulk_enrollment_group_operation {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Mode {
+        #[serde(rename = "create")]
+        Create,
+        #[serde(rename = "update")]
+        Update,
+        #[serde(rename = "updateIfMatchETag")]
+        UpdateIfMatchETag,
+        #[serde(rename = "delete")]
+        Delete,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BulkEnrollmentGroupOperationResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub errors: Vec<BulkEnrollmentGroupOperationError>,
+    #[serde(rename = "isSuccessful")]
+    pub is_successful: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BulkEnrollmentGroupOperationError {
+    #[serde(rename = "enrollmentGroupId")]
+    pub enrollment_group_id: String,
+    #[serde(rename = "errorCode")]
+    pub error_code: i32,
+    #[serde(rename = "errorStatus")]
+    pub error_status: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TwinCollection {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<Metadata>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Metadata {
+    #[serde(rename = "lastUpdated", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated: Option<String>,
+    #[serde(rename = "lastUpdatedVersion", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated_version: Option<i64>,
+}
diff --git a/services/svc/deviceprovisioningservices/src/package_2021_10_01/operations.rs b/services/svc/deviceprovisioningservices/src/package_2021_10_01/operations.rs
new file mode 100644
index 0000000000..837407e774
--- /dev/null
+++ b/services/svc/deviceprovisioningservices/src/package_2021_10_01/operations.rs
@@ -0,0 +1,991 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod individual_enrollment {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, id: &str) -> std::result::Result<IndividualEnrollment, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollments/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IndividualEnrollment =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+        enrollment: &IndividualEnrollment,
+        if_match: Option<&str>,
+    ) -> std::result::Result<IndividualEnrollment, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollments/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(enrollment).map_err(create_or_update::Error::SerializeError)?;
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IndividualEnrollment = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+        if_match: Option<&str>,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollments/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query(
+        operation_config: &crate::OperationConfig,
+        x_ms_max_item_count: Option<i32>,
+        x_ms_continuation: Option<&str>,
+        query_specification: &QuerySpecification,
+    ) -> std::result::Result<Vec<IndividualEnrollment>, query::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollments/query", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_max_item_count) = x_ms_max_item_count {
+            req_builder = req_builder.header("x-ms-max-item-count", x_ms_max_item_count);
+        }
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        let req_body = azure_core::to_json(query_specification).map_err(query::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(query::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Vec<IndividualEnrollment> =
+                    serde_json::from_slice(rsp_body).map_err(|source| query::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| query::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_attestation_mechanism(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+    ) -> std::result::Result<AttestationMechanism, get_attestation_mechanism::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollments/{}/attestationmechanism", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(get_attestation_mechanism::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_attestation_mechanism::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_attestation_mechanism::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_attestation_mechanism::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestationMechanism = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_attestation_mechanism::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_attestation_mechanism::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_attestation_mechanism::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_attestation_mechanism {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_bulk_operation(
+        operation_config: &crate::OperationConfig,
+        bulk_operation: &BulkEnrollmentOperation,
+    ) -> std::result::Result<BulkEnrollmentOperationResult, run_bulk_operation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollments", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(run_bulk_operation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_bulk_operation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(bulk_operation).map_err(run_bulk_operation::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_bulk_operation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_bulk_operation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BulkEnrollmentOperationResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_bulk_operation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_bulk_operation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(run_bulk_operation::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod run_bulk_operation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod enrollment_group {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, id: &str) -> std::result::Result<EnrollmentGroup, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollmentGroups/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: EnrollmentGroup =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+        enrollment_group: &EnrollmentGroup,
+        if_match: Option<&str>,
+    ) -> std::result::Result<EnrollmentGroup, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollmentGroups/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(enrollment_group).map_err(create_or_update::Error::SerializeError)?;
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: EnrollmentGroup = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+        if_match: Option<&str>,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollmentGroups/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query(
+        operation_config: &crate::OperationConfig,
+        x_ms_max_item_count: Option<i32>,
+        x_ms_continuation: Option<&str>,
+        query_specification: &QuerySpecification,
+    ) -> std::result::Result<Vec<EnrollmentGroup>, query::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollmentGroups/query", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_max_item_count) = x_ms_max_item_count {
+            req_builder = req_builder.header("x-ms-max-item-count", x_ms_max_item_count);
+        }
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        let req_body = azure_core::to_json(query_specification).map_err(query::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(query::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Vec<EnrollmentGroup> =
+                    serde_json::from_slice(rsp_body).map_err(|source| query::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| query::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_attestation_mechanism(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+    ) -> std::result::Result<AttestationMechanism, get_attestation_mechanism::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollmentGroups/{}/attestationmechanism", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(get_attestation_mechanism::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_attestation_mechanism::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_attestation_mechanism::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_attestation_mechanism::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestationMechanism = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_attestation_mechanism::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_attestation_mechanism::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_attestation_mechanism::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_attestation_mechanism {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_bulk_operation(
+        operation_config: &crate::OperationConfig,
+        bulk_operation: &BulkEnrollmentGroupOperation,
+    ) -> std::result::Result<BulkEnrollmentGroupOperationResult, run_bulk_operation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/enrollmentGroups", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(run_bulk_operation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_bulk_operation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(bulk_operation).map_err(run_bulk_operation::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_bulk_operation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_bulk_operation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BulkEnrollmentGroupOperationResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_bulk_operation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_bulk_operation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(run_bulk_operation::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod run_bulk_operation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod device_registration_state {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, id: &str) -> std::result::Result<DeviceRegistrationState, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/registrations/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceRegistrationState =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+        if_match: Option<&str>,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/registrations/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+        x_ms_max_item_count: Option<i32>,
+        x_ms_continuation: Option<&str>,
+    ) -> std::result::Result<Vec<DeviceRegistrationState>, query::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/registrations/{}/query", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(query::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_max_item_count) = x_ms_max_item_count {
+            req_builder = req_builder.header("x-ms-max-item-count", x_ms_max_item_count);
+        }
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(query::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Vec<DeviceRegistrationState> =
+                    serde_json::from_slice(rsp_body).map_err(|source| query::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProvisioningServiceErrorDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| query::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ProvisioningServiceErrorDetails,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/eventgrid/Cargo.toml b/services/svc/eventgrid/Cargo.toml
new file mode 100644
index 0000000000..e128704a28
--- /dev/null
+++ b/services/svc/eventgrid/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_eventgrid"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2018-01"]
+"package-2018-01" = []
diff --git a/services/svc/eventgrid/src/lib.rs b/services/svc/eventgrid/src/lib.rs
new file mode 100644
index 0000000000..675f377f1b
--- /dev/null
+++ b/services/svc/eventgrid/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2018-01")]
+mod package_2018_01;
+use azure_core::setters;
+#[cfg(feature = "package-2018-01")]
+pub use package_2018_01::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/eventgrid/src/package_2018_01/mod.rs b/services/svc/eventgrid/src/package_2018_01/mod.rs
new file mode 100644
index 0000000000..bf41ff1131
--- /dev/null
+++ b/services/svc/eventgrid/src/package_2018_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2018-01-01";
diff --git a/services/svc/eventgrid/src/package_2018_01/models.rs b/services/svc/eventgrid/src/package_2018_01/models.rs
new file mode 100644
index 0000000000..5c71c47294
--- /dev/null
+++ b/services/svc/eventgrid/src/package_2018_01/models.rs
@@ -0,0 +1,2301 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageBlobCreatedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(rename = "eTag", default, skip_serializing_if = "Option::is_none")]
+    pub e_tag: Option<String>,
+    #[serde(rename = "contentType", default, skip_serializing_if = "Option::is_none")]
+    pub content_type: Option<String>,
+    #[serde(rename = "contentLength", default, skip_serializing_if = "Option::is_none")]
+    pub content_length: Option<i64>,
+    #[serde(rename = "contentOffset", default, skip_serializing_if = "Option::is_none")]
+    pub content_offset: Option<i64>,
+    #[serde(rename = "blobType", default, skip_serializing_if = "Option::is_none")]
+    pub blob_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sequencer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "storageDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub storage_diagnostics: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageBlobDeletedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(rename = "contentType", default, skip_serializing_if = "Option::is_none")]
+    pub content_type: Option<String>,
+    #[serde(rename = "blobType", default, skip_serializing_if = "Option::is_none")]
+    pub blob_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sequencer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "storageDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub storage_diagnostics: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageDirectoryCreatedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(rename = "eTag", default, skip_serializing_if = "Option::is_none")]
+    pub e_tag: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sequencer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "storageDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub storage_diagnostics: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageDirectoryDeletedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sequencer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "storageDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub storage_diagnostics: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageBlobRenamedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(rename = "sourceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub source_url: Option<String>,
+    #[serde(rename = "destinationUrl", default, skip_serializing_if = "Option::is_none")]
+    pub destination_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sequencer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "storageDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub storage_diagnostics: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageDirectoryRenamedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(rename = "sourceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub source_url: Option<String>,
+    #[serde(rename = "destinationUrl", default, skip_serializing_if = "Option::is_none")]
+    pub destination_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sequencer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "storageDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub storage_diagnostics: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageLifecyclePolicyCompletedEventData {
+    #[serde(rename = "scheduleTime", default, skip_serializing_if = "Option::is_none")]
+    pub schedule_time: Option<String>,
+    #[serde(rename = "deleteSummary", default, skip_serializing_if = "Option::is_none")]
+    pub delete_summary: Option<StorageLifecyclePolicyActionSummaryDetail>,
+    #[serde(rename = "tierToCoolSummary", default, skip_serializing_if = "Option::is_none")]
+    pub tier_to_cool_summary: Option<StorageLifecyclePolicyActionSummaryDetail>,
+    #[serde(rename = "tierToArchiveSummary", default, skip_serializing_if = "Option::is_none")]
+    pub tier_to_archive_summary: Option<StorageLifecyclePolicyActionSummaryDetail>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageLifecyclePolicyActionSummaryDetail {
+    #[serde(rename = "totalObjectsCount", default, skip_serializing_if = "Option::is_none")]
+    pub total_objects_count: Option<i64>,
+    #[serde(rename = "successCount", default, skip_serializing_if = "Option::is_none")]
+    pub success_count: Option<i64>,
+    #[serde(rename = "errorList", default, skip_serializing_if = "Option::is_none")]
+    pub error_list: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageBlobTierChangedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(rename = "contentType", default, skip_serializing_if = "Option::is_none")]
+    pub content_type: Option<String>,
+    #[serde(rename = "contentLength", default, skip_serializing_if = "Option::is_none")]
+    pub content_length: Option<i64>,
+    #[serde(rename = "blobType", default, skip_serializing_if = "Option::is_none")]
+    pub blob_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sequencer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "storageDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub storage_diagnostics: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageAsyncOperationInitiatedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub api: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(rename = "contentType", default, skip_serializing_if = "Option::is_none")]
+    pub content_type: Option<String>,
+    #[serde(rename = "contentLength", default, skip_serializing_if = "Option::is_none")]
+    pub content_length: Option<i64>,
+    #[serde(rename = "blobType", default, skip_serializing_if = "Option::is_none")]
+    pub blob_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sequencer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    #[serde(rename = "storageDiagnostics", default, skip_serializing_if = "Option::is_none")]
+    pub storage_diagnostics: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageBlobInventoryPolicyCompletedEventData {
+    #[serde(rename = "scheduleDateTime", default, skip_serializing_if = "Option::is_none")]
+    pub schedule_date_time: Option<String>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<String>,
+    #[serde(rename = "ruleName", default, skip_serializing_if = "Option::is_none")]
+    pub rule_name: Option<String>,
+    #[serde(rename = "policyRunStatus", default, skip_serializing_if = "Option::is_none")]
+    pub policy_run_status: Option<String>,
+    #[serde(rename = "policyRunStatusMessage", default, skip_serializing_if = "Option::is_none")]
+    pub policy_run_status_message: Option<String>,
+    #[serde(rename = "policyRunId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_run_id: Option<String>,
+    #[serde(rename = "manifestBlobUrl", default, skip_serializing_if = "Option::is_none")]
+    pub manifest_blob_url: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventHubCaptureFileCreatedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub fileurl: Option<String>,
+    #[serde(rename = "fileType", default, skip_serializing_if = "Option::is_none")]
+    pub file_type: Option<String>,
+    #[serde(rename = "partitionId", default, skip_serializing_if = "Option::is_none")]
+    pub partition_id: Option<String>,
+    #[serde(rename = "sizeInBytes", default, skip_serializing_if = "Option::is_none")]
+    pub size_in_bytes: Option<i64>,
+    #[serde(rename = "eventCount", default, skip_serializing_if = "Option::is_none")]
+    pub event_count: Option<i64>,
+    #[serde(rename = "firstSequenceNumber", default, skip_serializing_if = "Option::is_none")]
+    pub first_sequence_number: Option<i64>,
+    #[serde(rename = "lastSequenceNumber", default, skip_serializing_if = "Option::is_none")]
+    pub last_sequence_number: Option<i64>,
+    #[serde(rename = "firstEnqueueTime", default, skip_serializing_if = "Option::is_none")]
+    pub first_enqueue_time: Option<String>,
+    #[serde(rename = "lastEnqueueTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_enqueue_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceWriteSuccessData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceWriteFailureData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceWriteCancelData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceDeleteSuccessData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceDeleteFailureData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceDeleteCancelData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceActionSuccessData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceActionFailureData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceActionCancelData {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "resourceProvider", default, skip_serializing_if = "Option::is_none")]
+    pub resource_provider: Option<String>,
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+    #[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
+    pub operation_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authorization: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub claims: Option<String>,
+    #[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_id: Option<String>,
+    #[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
+    pub http_request: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventGridEvent {
+    pub id: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub topic: Option<String>,
+    pub subject: String,
+    pub data: serde_json::Value,
+    #[serde(rename = "eventType")]
+    pub event_type: String,
+    #[serde(rename = "eventTime")]
+    pub event_time: String,
+    #[serde(rename = "metadataVersion", default, skip_serializing_if = "Option::is_none")]
+    pub metadata_version: Option<String>,
+    #[serde(rename = "dataVersion")]
+    pub data_version: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudEventEvent {
+    pub id: String,
+    pub source: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data_base64: Option<String>,
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    pub specversion: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataschema: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub datacontenttype: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub subject: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomEventEvent {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubscriptionValidationEventData {
+    #[serde(rename = "validationCode", default, skip_serializing_if = "Option::is_none")]
+    pub validation_code: Option<String>,
+    #[serde(rename = "validationUrl", default, skip_serializing_if = "Option::is_none")]
+    pub validation_url: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubscriptionValidationResponse {
+    #[serde(rename = "validationResponse", default, skip_serializing_if = "Option::is_none")]
+    pub validation_response: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubscriptionDeletedEventData {
+    #[serde(rename = "eventSubscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub event_subscription_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IotHubDeviceCreatedEventData {
+    #[serde(flatten)]
+    pub device_life_cycle_event_properties: DeviceLifeCycleEventProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IotHubDeviceDeletedEventData {
+    #[serde(flatten)]
+    pub device_life_cycle_event_properties: DeviceLifeCycleEventProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IotHubDeviceConnectedEventData {
+    #[serde(flatten)]
+    pub device_connection_state_event_properties: DeviceConnectionStateEventProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IotHubDeviceDisconnectedEventData {
+    #[serde(flatten)]
+    pub device_connection_state_event_properties: DeviceConnectionStateEventProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IotHubDeviceTelemetryEventData {
+    #[serde(flatten)]
+    pub device_telemetry_event_properties: DeviceTelemetryEventProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceLifeCycleEventProperties {
+    #[serde(rename = "deviceId", default, skip_serializing_if = "Option::is_none")]
+    pub device_id: Option<String>,
+    #[serde(rename = "hubName", default, skip_serializing_if = "Option::is_none")]
+    pub hub_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub twin: Option<DeviceTwinInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceConnectionStateEventProperties {
+    #[serde(rename = "deviceId", default, skip_serializing_if = "Option::is_none")]
+    pub device_id: Option<String>,
+    #[serde(rename = "moduleId", default, skip_serializing_if = "Option::is_none")]
+    pub module_id: Option<String>,
+    #[serde(rename = "hubName", default, skip_serializing_if = "Option::is_none")]
+    pub hub_name: Option<String>,
+    #[serde(rename = "deviceConnectionStateEventInfo", default, skip_serializing_if = "Option::is_none")]
+    pub device_connection_state_event_info: Option<DeviceConnectionStateEventInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTelemetryEventProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(rename = "systemProperties", default, skip_serializing_if = "Option::is_none")]
+    pub system_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTwinInfo {
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<String>,
+    #[serde(rename = "cloudToDeviceMessageCount", default, skip_serializing_if = "Option::is_none")]
+    pub cloud_to_device_message_count: Option<f64>,
+    #[serde(rename = "connectionState", default, skip_serializing_if = "Option::is_none")]
+    pub connection_state: Option<String>,
+    #[serde(rename = "deviceId", default, skip_serializing_if = "Option::is_none")]
+    pub device_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "lastActivityTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_activity_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<device_twin_info::Properties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "statusUpdateTime", default, skip_serializing_if = "Option::is_none")]
+    pub status_update_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<f64>,
+    #[serde(rename = "x509Thumbprint", default, skip_serializing_if = "Option::is_none")]
+    pub x509_thumbprint: Option<device_twin_info::X509Thumbprint>,
+}
+pub mod device_twin_info {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Properties {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub desired: Option<DeviceTwinProperties>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub reported: Option<DeviceTwinProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct X509Thumbprint {
+        #[serde(rename = "primaryThumbprint", default, skip_serializing_if = "Option::is_none")]
+        pub primary_thumbprint: Option<String>,
+        #[serde(rename = "secondaryThumbprint", default, skip_serializing_if = "Option::is_none")]
+        pub secondary_thumbprint: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTwinProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<DeviceTwinMetadata>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTwinMetadata {
+    #[serde(rename = "lastUpdated", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceConnectionStateEventInfo {
+    #[serde(rename = "sequenceNumber", default, skip_serializing_if = "Option::is_none")]
+    pub sequence_number: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryImagePushedEventData {
+    #[serde(flatten)]
+    pub container_registry_event_data: ContainerRegistryEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryImageDeletedEventData {
+    #[serde(flatten)]
+    pub container_registry_event_data: ContainerRegistryEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryChartPushedEventData {
+    #[serde(flatten)]
+    pub container_registry_artifact_event_data: ContainerRegistryArtifactEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryChartDeletedEventData {
+    #[serde(flatten)]
+    pub container_registry_artifact_event_data: ContainerRegistryArtifactEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub action: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<ContainerRegistryEventTarget>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub request: Option<ContainerRegistryEventRequest>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub actor: Option<ContainerRegistryEventActor>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<ContainerRegistryEventSource>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryArtifactEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub action: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<ContainerRegistryArtifactEventTarget>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryEventTarget {
+    #[serde(rename = "mediaType", default, skip_serializing_if = "Option::is_none")]
+    pub media_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub digest: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub length: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub repository: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tag: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryArtifactEventTarget {
+    #[serde(rename = "mediaType", default, skip_serializing_if = "Option::is_none")]
+    pub media_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub digest: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub repository: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tag: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryEventRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub addr: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub host: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub method: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub useragent: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryEventActor {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerRegistryEventSource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub addr: Option<String>,
+    #[serde(rename = "instanceID", default, skip_serializing_if = "Option::is_none")]
+    pub instance_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceBusActiveMessagesAvailableWithNoListenersEventData {
+    #[serde(rename = "namespaceName", default, skip_serializing_if = "Option::is_none")]
+    pub namespace_name: Option<String>,
+    #[serde(rename = "requestUri", default, skip_serializing_if = "Option::is_none")]
+    pub request_uri: Option<String>,
+    #[serde(rename = "entityType", default, skip_serializing_if = "Option::is_none")]
+    pub entity_type: Option<String>,
+    #[serde(rename = "queueName", default, skip_serializing_if = "Option::is_none")]
+    pub queue_name: Option<String>,
+    #[serde(rename = "topicName", default, skip_serializing_if = "Option::is_none")]
+    pub topic_name: Option<String>,
+    #[serde(rename = "subscriptionName", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceBusDeadletterMessagesAvailableWithNoListenersEventData {
+    #[serde(rename = "namespaceName", default, skip_serializing_if = "Option::is_none")]
+    pub namespace_name: Option<String>,
+    #[serde(rename = "requestUri", default, skip_serializing_if = "Option::is_none")]
+    pub request_uri: Option<String>,
+    #[serde(rename = "entityType", default, skip_serializing_if = "Option::is_none")]
+    pub entity_type: Option<String>,
+    #[serde(rename = "queueName", default, skip_serializing_if = "Option::is_none")]
+    pub queue_name: Option<String>,
+    #[serde(rename = "topicName", default, skip_serializing_if = "Option::is_none")]
+    pub topic_name: Option<String>,
+    #[serde(rename = "subscriptionName", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceBusActiveMessagesAvailablePeriodicNotificationsEventData {
+    #[serde(rename = "namespaceName", default, skip_serializing_if = "Option::is_none")]
+    pub namespace_name: Option<String>,
+    #[serde(rename = "requestUri", default, skip_serializing_if = "Option::is_none")]
+    pub request_uri: Option<String>,
+    #[serde(rename = "entityType", default, skip_serializing_if = "Option::is_none")]
+    pub entity_type: Option<String>,
+    #[serde(rename = "queueName", default, skip_serializing_if = "Option::is_none")]
+    pub queue_name: Option<String>,
+    #[serde(rename = "topicName", default, skip_serializing_if = "Option::is_none")]
+    pub topic_name: Option<String>,
+    #[serde(rename = "subscriptionName", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceBusDeadletterMessagesAvailablePeriodicNotificationsEventData {
+    #[serde(rename = "namespaceName", default, skip_serializing_if = "Option::is_none")]
+    pub namespace_name: Option<String>,
+    #[serde(rename = "requestUri", default, skip_serializing_if = "Option::is_none")]
+    pub request_uri: Option<String>,
+    #[serde(rename = "entityType", default, skip_serializing_if = "Option::is_none")]
+    pub entity_type: Option<String>,
+    #[serde(rename = "queueName", default, skip_serializing_if = "Option::is_none")]
+    pub queue_name: Option<String>,
+    #[serde(rename = "topicName", default, skip_serializing_if = "Option::is_none")]
+    pub topic_name: Option<String>,
+    #[serde(rename = "subscriptionName", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobStateChangeEventData {
+    #[serde(rename = "previousState", default, skip_serializing_if = "Option::is_none")]
+    pub previous_state: Option<media_job_state_change_event_data::PreviousState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<media_job_state_change_event_data::State>,
+    #[serde(rename = "correlationData", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_data: Option<serde_json::Value>,
+}
+pub mod media_job_state_change_event_data {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PreviousState {
+        Canceled,
+        Canceling,
+        Error,
+        Finished,
+        Processing,
+        Queued,
+        Scheduled,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        Canceled,
+        Canceling,
+        Error,
+        Finished,
+        Processing,
+        Queued,
+        Scheduled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<media_job_error::Code>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub category: Option<media_job_error::Category>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub retry: Option<media_job_error::Retry>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<MediaJobErrorDetail>,
+}
+pub mod media_job_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Code {
+        ServiceError,
+        ServiceTransientError,
+        DownloadNotAccessible,
+        DownloadTransientError,
+        UploadNotAccessible,
+        UploadTransientError,
+        ConfigurationUnsupported,
+        ContentMalformed,
+        ContentUnsupported,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Category {
+        Service,
+        Download,
+        Upload,
+        Configuration,
+        Content,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Retry {
+        DoNotRetry,
+        MayRetry,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobErrorDetail {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutput {
+    #[serde(rename = "@odata.type", default, skip_serializing_if = "Option::is_none")]
+    pub odata_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<MediaJobError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    pub progress: i64,
+    pub state: media_job_output::State,
+}
+pub mod media_job_output {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        Canceled,
+        Canceling,
+        Error,
+        Finished,
+        Processing,
+        Queued,
+        Scheduled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputAsset {
+    #[serde(flatten)]
+    pub media_job_output: MediaJobOutput,
+    #[serde(rename = "assetName", default, skip_serializing_if = "Option::is_none")]
+    pub asset_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputProgressEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub progress: Option<i64>,
+    #[serde(rename = "jobCorrelationData", default, skip_serializing_if = "Option::is_none")]
+    pub job_correlation_data: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputStateChangeEventData {
+    #[serde(rename = "previousState", default, skip_serializing_if = "Option::is_none")]
+    pub previous_state: Option<media_job_output_state_change_event_data::PreviousState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<MediaJobOutput>,
+    #[serde(rename = "jobCorrelationData", default, skip_serializing_if = "Option::is_none")]
+    pub job_correlation_data: Option<serde_json::Value>,
+}
+pub mod media_job_output_state_change_event_data {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PreviousState {
+        Canceled,
+        Canceling,
+        Error,
+        Finished,
+        Processing,
+        Queued,
+        Scheduled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobScheduledEventData {
+    #[serde(flatten)]
+    pub media_job_state_change_event_data: MediaJobStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobProcessingEventData {
+    #[serde(flatten)]
+    pub media_job_state_change_event_data: MediaJobStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobCancelingEventData {
+    #[serde(flatten)]
+    pub media_job_state_change_event_data: MediaJobStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobFinishedEventData {
+    #[serde(flatten)]
+    pub media_job_state_change_event_data: MediaJobStateChangeEventData,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<MediaJobOutput>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobCanceledEventData {
+    #[serde(flatten)]
+    pub media_job_state_change_event_data: MediaJobStateChangeEventData,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<MediaJobOutput>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobErroredEventData {
+    #[serde(flatten)]
+    pub media_job_state_change_event_data: MediaJobStateChangeEventData,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<MediaJobOutput>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputCanceledEventData {
+    #[serde(flatten)]
+    pub media_job_output_state_change_event_data: MediaJobOutputStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputCancelingEventData {
+    #[serde(flatten)]
+    pub media_job_output_state_change_event_data: MediaJobOutputStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputErroredEventData {
+    #[serde(flatten)]
+    pub media_job_output_state_change_event_data: MediaJobOutputStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputFinishedEventData {
+    #[serde(flatten)]
+    pub media_job_output_state_change_event_data: MediaJobOutputStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputProcessingEventData {
+    #[serde(flatten)]
+    pub media_job_output_state_change_event_data: MediaJobOutputStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaJobOutputScheduledEventData {
+    #[serde(flatten)]
+    pub media_job_output_state_change_event_data: MediaJobOutputStateChangeEventData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventEncoderConnectedEventData {
+    #[serde(rename = "ingestUrl", default, skip_serializing_if = "Option::is_none")]
+    pub ingest_url: Option<String>,
+    #[serde(rename = "streamId", default, skip_serializing_if = "Option::is_none")]
+    pub stream_id: Option<String>,
+    #[serde(rename = "encoderIp", default, skip_serializing_if = "Option::is_none")]
+    pub encoder_ip: Option<String>,
+    #[serde(rename = "encoderPort", default, skip_serializing_if = "Option::is_none")]
+    pub encoder_port: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventConnectionRejectedEventData {
+    #[serde(rename = "ingestUrl", default, skip_serializing_if = "Option::is_none")]
+    pub ingest_url: Option<String>,
+    #[serde(rename = "streamId", default, skip_serializing_if = "Option::is_none")]
+    pub stream_id: Option<String>,
+    #[serde(rename = "encoderIp", default, skip_serializing_if = "Option::is_none")]
+    pub encoder_ip: Option<String>,
+    #[serde(rename = "encoderPort", default, skip_serializing_if = "Option::is_none")]
+    pub encoder_port: Option<String>,
+    #[serde(rename = "resultCode", default, skip_serializing_if = "Option::is_none")]
+    pub result_code: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventEncoderDisconnectedEventData {
+    #[serde(rename = "ingestUrl", default, skip_serializing_if = "Option::is_none")]
+    pub ingest_url: Option<String>,
+    #[serde(rename = "streamId", default, skip_serializing_if = "Option::is_none")]
+    pub stream_id: Option<String>,
+    #[serde(rename = "encoderIp", default, skip_serializing_if = "Option::is_none")]
+    pub encoder_ip: Option<String>,
+    #[serde(rename = "encoderPort", default, skip_serializing_if = "Option::is_none")]
+    pub encoder_port: Option<String>,
+    #[serde(rename = "resultCode", default, skip_serializing_if = "Option::is_none")]
+    pub result_code: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventIncomingStreamReceivedEventData {
+    #[serde(rename = "ingestUrl", default, skip_serializing_if = "Option::is_none")]
+    pub ingest_url: Option<String>,
+    #[serde(rename = "trackType", default, skip_serializing_if = "Option::is_none")]
+    pub track_type: Option<String>,
+    #[serde(rename = "trackName", default, skip_serializing_if = "Option::is_none")]
+    pub track_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bitrate: Option<i64>,
+    #[serde(rename = "encoderIp", default, skip_serializing_if = "Option::is_none")]
+    pub encoder_ip: Option<String>,
+    #[serde(rename = "encoderPort", default, skip_serializing_if = "Option::is_none")]
+    pub encoder_port: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub duration: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timescale: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventIncomingStreamsOutOfSyncEventData {
+    #[serde(rename = "minLastTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub min_last_timestamp: Option<String>,
+    #[serde(rename = "typeOfStreamWithMinLastTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub type_of_stream_with_min_last_timestamp: Option<String>,
+    #[serde(rename = "maxLastTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub max_last_timestamp: Option<String>,
+    #[serde(rename = "typeOfStreamWithMaxLastTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub type_of_stream_with_max_last_timestamp: Option<String>,
+    #[serde(rename = "timescaleOfMinLastTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub timescale_of_min_last_timestamp: Option<String>,
+    #[serde(rename = "timescaleOfMaxLastTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub timescale_of_max_last_timestamp: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventIncomingVideoStreamsOutOfSyncEventData {
+    #[serde(rename = "firstTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub first_timestamp: Option<String>,
+    #[serde(rename = "firstDuration", default, skip_serializing_if = "Option::is_none")]
+    pub first_duration: Option<String>,
+    #[serde(rename = "secondTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub second_timestamp: Option<String>,
+    #[serde(rename = "secondDuration", default, skip_serializing_if = "Option::is_none")]
+    pub second_duration: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timescale: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventIncomingDataChunkDroppedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(rename = "trackType", default, skip_serializing_if = "Option::is_none")]
+    pub track_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bitrate: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timescale: Option<String>,
+    #[serde(rename = "resultCode", default, skip_serializing_if = "Option::is_none")]
+    pub result_code: Option<String>,
+    #[serde(rename = "trackName", default, skip_serializing_if = "Option::is_none")]
+    pub track_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventIngestHeartbeatEventData {
+    #[serde(rename = "trackType", default, skip_serializing_if = "Option::is_none")]
+    pub track_type: Option<String>,
+    #[serde(rename = "trackName", default, skip_serializing_if = "Option::is_none")]
+    pub track_name: Option<String>,
+    #[serde(rename = "transcriptionLanguage", default, skip_serializing_if = "Option::is_none")]
+    pub transcription_language: Option<String>,
+    #[serde(rename = "transcriptionState", default, skip_serializing_if = "Option::is_none")]
+    pub transcription_state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bitrate: Option<i64>,
+    #[serde(rename = "incomingBitrate", default, skip_serializing_if = "Option::is_none")]
+    pub incoming_bitrate: Option<i64>,
+    #[serde(rename = "ingestDriftValue", default, skip_serializing_if = "Option::is_none")]
+    pub ingest_drift_value: Option<String>,
+    #[serde(rename = "lastFragmentArrivalTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_fragment_arrival_time: Option<String>,
+    #[serde(rename = "lastTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub last_timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timescale: Option<String>,
+    #[serde(rename = "overlapCount", default, skip_serializing_if = "Option::is_none")]
+    pub overlap_count: Option<i64>,
+    #[serde(rename = "discontinuityCount", default, skip_serializing_if = "Option::is_none")]
+    pub discontinuity_count: Option<i64>,
+    #[serde(rename = "nonincreasingCount", default, skip_serializing_if = "Option::is_none")]
+    pub nonincreasing_count: Option<i64>,
+    #[serde(rename = "unexpectedBitrate", default, skip_serializing_if = "Option::is_none")]
+    pub unexpected_bitrate: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub healthy: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventTrackDiscontinuityDetectedEventData {
+    #[serde(rename = "trackType", default, skip_serializing_if = "Option::is_none")]
+    pub track_type: Option<String>,
+    #[serde(rename = "trackName", default, skip_serializing_if = "Option::is_none")]
+    pub track_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bitrate: Option<i64>,
+    #[serde(rename = "previousTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub previous_timestamp: Option<String>,
+    #[serde(rename = "newTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub new_timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timescale: Option<String>,
+    #[serde(rename = "discontinuityGap", default, skip_serializing_if = "Option::is_none")]
+    pub discontinuity_gap: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaLiveEventChannelArchiveHeartbeatEventData {
+    #[serde(rename = "channelLatencyMs")]
+    pub channel_latency_ms: String,
+    #[serde(rename = "latencyResultCode")]
+    pub latency_result_code: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MapsGeofenceEnteredEventData {
+    #[serde(flatten)]
+    pub maps_geofence_event_properties: MapsGeofenceEventProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MapsGeofenceExitedEventData {
+    #[serde(flatten)]
+    pub maps_geofence_event_properties: MapsGeofenceEventProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MapsGeofenceResultEventData {
+    #[serde(flatten)]
+    pub maps_geofence_event_properties: MapsGeofenceEventProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MapsGeofenceEventProperties {
+    #[serde(rename = "expiredGeofenceGeometryId", default, skip_serializing_if = "Vec::is_empty")]
+    pub expired_geofence_geometry_id: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub geometries: Vec<MapsGeofenceGeometry>,
+    #[serde(rename = "invalidPeriodGeofenceGeometryId", default, skip_serializing_if = "Vec::is_empty")]
+    pub invalid_period_geofence_geometry_id: Vec<String>,
+    #[serde(rename = "isEventPublished", default, skip_serializing_if = "Option::is_none")]
+    pub is_event_published: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MapsGeofenceGeometry {
+    #[serde(rename = "deviceId", default, skip_serializing_if = "Option::is_none")]
+    pub device_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub distance: Option<f64>,
+    #[serde(rename = "geometryId", default, skip_serializing_if = "Option::is_none")]
+    pub geometry_id: Option<String>,
+    #[serde(rename = "nearestLat", default, skip_serializing_if = "Option::is_none")]
+    pub nearest_lat: Option<f64>,
+    #[serde(rename = "nearestLon", default, skip_serializing_if = "Option::is_none")]
+    pub nearest_lon: Option<f64>,
+    #[serde(rename = "udId", default, skip_serializing_if = "Option::is_none")]
+    pub ud_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppConfigurationKeyValueModifiedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "syncToken", default, skip_serializing_if = "Option::is_none")]
+    pub sync_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppConfigurationKeyValueDeletedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub label: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "syncToken", default, skip_serializing_if = "Option::is_none")]
+    pub sync_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SignalRServiceClientConnectionConnectedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(rename = "hubName", default, skip_serializing_if = "Option::is_none")]
+    pub hub_name: Option<String>,
+    #[serde(rename = "connectionId", default, skip_serializing_if = "Option::is_none")]
+    pub connection_id: Option<String>,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SignalRServiceClientConnectionDisconnectedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(rename = "hubName", default, skip_serializing_if = "Option::is_none")]
+    pub hub_name: Option<String>,
+    #[serde(rename = "connectionId", default, skip_serializing_if = "Option::is_none")]
+    pub connection_id: Option<String>,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<String>,
+    #[serde(rename = "errorMessage", default, skip_serializing_if = "Option::is_none")]
+    pub error_message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultCertificateNewVersionCreatedEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultCertificateNearExpiryEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultCertificateExpiredEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultKeyNewVersionCreatedEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultKeyNearExpiryEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultKeyExpiredEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultSecretNewVersionCreatedEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultSecretNearExpiryEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultSecretExpiredEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyVaultVaultAccessPolicyChangedEventData {
+    #[serde(rename = "Id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "VaultName", default, skip_serializing_if = "Option::is_none")]
+    pub vault_name: Option<String>,
+    #[serde(rename = "ObjectType", default, skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    #[serde(rename = "ObjectName", default, skip_serializing_if = "Option::is_none")]
+    pub object_name: Option<String>,
+    #[serde(rename = "Version", default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "NBF", default, skip_serializing_if = "Option::is_none")]
+    pub nbf: Option<f64>,
+    #[serde(rename = "EXP", default, skip_serializing_if = "Option::is_none")]
+    pub exp: Option<f64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MachineLearningServicesModelRegisteredEventData {
+    #[serde(rename = "modelName", default, skip_serializing_if = "Option::is_none")]
+    pub model_name: Option<String>,
+    #[serde(rename = "modelVersion", default, skip_serializing_if = "Option::is_none")]
+    pub model_version: Option<String>,
+    #[serde(rename = "modelTags", default, skip_serializing_if = "Option::is_none")]
+    pub model_tags: Option<serde_json::Value>,
+    #[serde(rename = "modelProperties", default, skip_serializing_if = "Option::is_none")]
+    pub model_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MachineLearningServicesModelDeployedEventData {
+    #[serde(rename = "serviceName", default, skip_serializing_if = "Option::is_none")]
+    pub service_name: Option<String>,
+    #[serde(rename = "serviceComputeType", default, skip_serializing_if = "Option::is_none")]
+    pub service_compute_type: Option<String>,
+    #[serde(rename = "modelIds", default, skip_serializing_if = "Option::is_none")]
+    pub model_ids: Option<String>,
+    #[serde(rename = "serviceTags", default, skip_serializing_if = "Option::is_none")]
+    pub service_tags: Option<serde_json::Value>,
+    #[serde(rename = "serviceProperties", default, skip_serializing_if = "Option::is_none")]
+    pub service_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MachineLearningServicesRunCompletedEventData {
+    #[serde(rename = "experimentId", default, skip_serializing_if = "Option::is_none")]
+    pub experiment_id: Option<String>,
+    #[serde(rename = "experimentName", default, skip_serializing_if = "Option::is_none")]
+    pub experiment_name: Option<String>,
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "runType", default, skip_serializing_if = "Option::is_none")]
+    pub run_type: Option<String>,
+    #[serde(rename = "runTags", default, skip_serializing_if = "Option::is_none")]
+    pub run_tags: Option<serde_json::Value>,
+    #[serde(rename = "runProperties", default, skip_serializing_if = "Option::is_none")]
+    pub run_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MachineLearningServicesDatasetDriftDetectedEventData {
+    #[serde(rename = "dataDriftId", default, skip_serializing_if = "Option::is_none")]
+    pub data_drift_id: Option<String>,
+    #[serde(rename = "dataDriftName", default, skip_serializing_if = "Option::is_none")]
+    pub data_drift_name: Option<String>,
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "baseDatasetId", default, skip_serializing_if = "Option::is_none")]
+    pub base_dataset_id: Option<String>,
+    #[serde(rename = "targetDatasetId", default, skip_serializing_if = "Option::is_none")]
+    pub target_dataset_id: Option<String>,
+    #[serde(rename = "driftCoefficient", default, skip_serializing_if = "Option::is_none")]
+    pub drift_coefficient: Option<f64>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MachineLearningServicesRunStatusChangedEventData {
+    #[serde(rename = "experimentId", default, skip_serializing_if = "Option::is_none")]
+    pub experiment_id: Option<String>,
+    #[serde(rename = "experimentName", default, skip_serializing_if = "Option::is_none")]
+    pub experiment_name: Option<String>,
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "runType", default, skip_serializing_if = "Option::is_none")]
+    pub run_type: Option<String>,
+    #[serde(rename = "runTags", default, skip_serializing_if = "Option::is_none")]
+    pub run_tags: Option<serde_json::Value>,
+    #[serde(rename = "runProperties", default, skip_serializing_if = "Option::is_none")]
+    pub run_properties: Option<serde_json::Value>,
+    #[serde(rename = "runStatus", default, skip_serializing_if = "Option::is_none")]
+    pub run_status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedisPatchingCompletedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedisScalingCompletedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedisExportRdbCompletedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedisImportRdbCompletedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebAppUpdatedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebBackupOperationStartedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebBackupOperationCompletedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebBackupOperationFailedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebRestoreOperationStartedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebRestoreOperationCompletedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebRestoreOperationFailedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSlotSwapStartedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSlotSwapCompletedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSlotSwapFailedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSlotSwapWithPreviewStartedEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSlotSwapWithPreviewCancelledEventData {
+    #[serde(rename = "appEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_event_type_detail: Option<AppEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebAppServicePlanUpdatedEventData {
+    #[serde(rename = "appServicePlanEventTypeDetail", default, skip_serializing_if = "Option::is_none")]
+    pub app_service_plan_event_type_detail: Option<AppServicePlanEventTypeDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<web_app_service_plan_updated_event_data::Sku>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub client_request_id: Option<String>,
+    #[serde(rename = "correlationRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub correlation_request_id: Option<String>,
+    #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
+    pub request_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub verb: Option<String>,
+}
+pub mod web_app_service_plan_updated_event_data {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Sku {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+        #[serde(rename = "Tier", default, skip_serializing_if = "Option::is_none")]
+        pub tier: Option<String>,
+        #[serde(rename = "Size", default, skip_serializing_if = "Option::is_none")]
+        pub size: Option<String>,
+        #[serde(rename = "Family", default, skip_serializing_if = "Option::is_none")]
+        pub family: Option<String>,
+        #[serde(rename = "Capacity", default, skip_serializing_if = "Option::is_none")]
+        pub capacity: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppEventTypeDetail {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub action: Option<app_event_type_detail::Action>,
+}
+pub mod app_event_type_detail {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Action {
+        Restarted,
+        Stopped,
+        ChangedAppSettings,
+        Started,
+        Completed,
+        Failed,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppServicePlanEventTypeDetail {
+    #[serde(rename = "stampKind", default, skip_serializing_if = "Option::is_none")]
+    pub stamp_kind: Option<app_service_plan_event_type_detail::StampKind>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub action: Option<app_service_plan_event_type_detail::Action>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<AsyncStatus>,
+}
+pub mod app_service_plan_event_type_detail {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum StampKind {
+        Public,
+        AseV1,
+        AseV2,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Action {
+        Updated,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AsyncStatus {
+    Started,
+    Completed,
+    Failed,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsUserDisconnectedEventData {
+    #[serde(rename = "userCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub user_communication_identifier: Option<CommunicationIdentifierModel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatMessageReceivedEventData {
+    #[serde(flatten)]
+    pub acs_chat_message_event_base_properties: AcsChatMessageEventBaseProperties,
+    #[serde(rename = "messageBody", default, skip_serializing_if = "Option::is_none")]
+    pub message_body: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatMessageReceivedInThreadEventData {
+    #[serde(flatten)]
+    pub acs_chat_message_event_in_thread_base_properties: AcsChatMessageEventInThreadBaseProperties,
+    #[serde(rename = "messageBody", default, skip_serializing_if = "Option::is_none")]
+    pub message_body: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatMessageEditedEventData {
+    #[serde(flatten)]
+    pub acs_chat_message_event_base_properties: AcsChatMessageEventBaseProperties,
+    #[serde(rename = "messageBody", default, skip_serializing_if = "Option::is_none")]
+    pub message_body: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+    #[serde(rename = "editTime", default, skip_serializing_if = "Option::is_none")]
+    pub edit_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatMessageEditedInThreadEventData {
+    #[serde(flatten)]
+    pub acs_chat_message_event_in_thread_base_properties: AcsChatMessageEventInThreadBaseProperties,
+    #[serde(rename = "messageBody", default, skip_serializing_if = "Option::is_none")]
+    pub message_body: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+    #[serde(rename = "editTime", default, skip_serializing_if = "Option::is_none")]
+    pub edit_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatMessageDeletedEventData {
+    #[serde(flatten)]
+    pub acs_chat_message_event_base_properties: AcsChatMessageEventBaseProperties,
+    #[serde(rename = "deleteTime", default, skip_serializing_if = "Option::is_none")]
+    pub delete_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatMessageDeletedInThreadEventData {
+    #[serde(flatten)]
+    pub acs_chat_message_event_in_thread_base_properties: AcsChatMessageEventInThreadBaseProperties,
+    #[serde(rename = "deleteTime", default, skip_serializing_if = "Option::is_none")]
+    pub delete_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadCreatedWithUserEventData {
+    #[serde(flatten)]
+    pub acs_chat_thread_event_base_properties: AcsChatThreadEventBaseProperties,
+    #[serde(rename = "createdByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub created_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub participants: Vec<AcsChatThreadParticipantProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadCreatedEventData {
+    #[serde(flatten)]
+    pub acs_chat_thread_event_in_thread_base_properties: AcsChatThreadEventInThreadBaseProperties,
+    #[serde(rename = "createdByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub created_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub participants: Vec<AcsChatThreadParticipantProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadWithUserDeletedEventData {
+    #[serde(flatten)]
+    pub acs_chat_thread_event_base_properties: AcsChatThreadEventBaseProperties,
+    #[serde(rename = "deletedByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub deleted_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "deleteTime", default, skip_serializing_if = "Option::is_none")]
+    pub delete_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadDeletedEventData {
+    #[serde(flatten)]
+    pub acs_chat_thread_event_in_thread_base_properties: AcsChatThreadEventInThreadBaseProperties,
+    #[serde(rename = "deletedByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub deleted_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "deleteTime", default, skip_serializing_if = "Option::is_none")]
+    pub delete_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadPropertiesUpdatedPerUserEventData {
+    #[serde(flatten)]
+    pub acs_chat_thread_event_base_properties: AcsChatThreadEventBaseProperties,
+    #[serde(rename = "editedByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub edited_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "editTime", default, skip_serializing_if = "Option::is_none")]
+    pub edit_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadPropertiesUpdatedEventData {
+    #[serde(flatten)]
+    pub acs_chat_thread_event_in_thread_base_properties: AcsChatThreadEventInThreadBaseProperties,
+    #[serde(rename = "editedByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub edited_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "editTime", default, skip_serializing_if = "Option::is_none")]
+    pub edit_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatParticipantAddedToThreadWithUserEventData {
+    #[serde(flatten)]
+    pub acs_chat_thread_event_base_properties: AcsChatThreadEventBaseProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    #[serde(rename = "addedByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub added_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "participantAdded", default, skip_serializing_if = "Option::is_none")]
+    pub participant_added: Option<AcsChatThreadParticipantProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatParticipantRemovedFromThreadWithUserEventData {
+    #[serde(flatten)]
+    pub acs_chat_thread_event_base_properties: AcsChatThreadEventBaseProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    #[serde(rename = "removedByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub removed_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "participantRemoved", default, skip_serializing_if = "Option::is_none")]
+    pub participant_removed: Option<AcsChatThreadParticipantProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatParticipantAddedToThreadEventData {
+    #[serde(flatten)]
+    pub acs_chat_event_in_thread_base_properties: AcsChatEventInThreadBaseProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    #[serde(rename = "addedByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub added_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "participantAdded", default, skip_serializing_if = "Option::is_none")]
+    pub participant_added: Option<AcsChatThreadParticipantProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatParticipantRemovedFromThreadEventData {
+    #[serde(flatten)]
+    pub acs_chat_event_in_thread_base_properties: AcsChatEventInThreadBaseProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    #[serde(rename = "removedByCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub removed_by_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "participantRemoved", default, skip_serializing_if = "Option::is_none")]
+    pub participant_removed: Option<AcsChatThreadParticipantProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsSmsDeliveryReportReceivedEventData {
+    #[serde(flatten)]
+    pub acs_sms_event_base_properties: AcsSmsEventBaseProperties,
+    #[serde(rename = "deliveryStatus", default, skip_serializing_if = "Option::is_none")]
+    pub delivery_status: Option<String>,
+    #[serde(rename = "deliveryStatusDetails", default, skip_serializing_if = "Option::is_none")]
+    pub delivery_status_details: Option<String>,
+    #[serde(rename = "deliveryAttempts", default, skip_serializing_if = "Vec::is_empty")]
+    pub delivery_attempts: Vec<AcsSmsDeliveryAttemptProperties>,
+    #[serde(rename = "receivedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub received_timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tag: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsSmsReceivedEventData {
+    #[serde(flatten)]
+    pub acs_sms_event_base_properties: AcsSmsEventBaseProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "receivedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub received_timestamp: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsRecordingFileStatusUpdatedEventData {
+    #[serde(rename = "recordingStorageInfo", default, skip_serializing_if = "Option::is_none")]
+    pub recording_storage_info: Option<AcsRecordingStorageInfoProperties>,
+    #[serde(rename = "recordingStartTime", default, skip_serializing_if = "Option::is_none")]
+    pub recording_start_time: Option<String>,
+    #[serde(rename = "recordingDurationMs", default, skip_serializing_if = "Option::is_none")]
+    pub recording_duration_ms: Option<i64>,
+    #[serde(rename = "sessionEndReason", default, skip_serializing_if = "Option::is_none")]
+    pub session_end_reason: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadEventBaseProperties {
+    #[serde(flatten)]
+    pub acs_chat_event_base_properties: AcsChatEventBaseProperties,
+    #[serde(rename = "createTime", default, skip_serializing_if = "Option::is_none")]
+    pub create_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadEventInThreadBaseProperties {
+    #[serde(flatten)]
+    pub acs_chat_event_in_thread_base_properties: AcsChatEventInThreadBaseProperties,
+    #[serde(rename = "createTime", default, skip_serializing_if = "Option::is_none")]
+    pub create_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatMessageEventBaseProperties {
+    #[serde(flatten)]
+    pub acs_chat_event_base_properties: AcsChatEventBaseProperties,
+    #[serde(rename = "messageId", default, skip_serializing_if = "Option::is_none")]
+    pub message_id: Option<String>,
+    #[serde(rename = "senderCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub sender_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "senderDisplayName", default, skip_serializing_if = "Option::is_none")]
+    pub sender_display_name: Option<String>,
+    #[serde(rename = "composeTime", default, skip_serializing_if = "Option::is_none")]
+    pub compose_time: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatMessageEventInThreadBaseProperties {
+    #[serde(flatten)]
+    pub acs_chat_event_in_thread_base_properties: AcsChatEventInThreadBaseProperties,
+    #[serde(rename = "messageId", default, skip_serializing_if = "Option::is_none")]
+    pub message_id: Option<String>,
+    #[serde(rename = "senderCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub sender_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "senderDisplayName", default, skip_serializing_if = "Option::is_none")]
+    pub sender_display_name: Option<String>,
+    #[serde(rename = "composeTime", default, skip_serializing_if = "Option::is_none")]
+    pub compose_time: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatEventInThreadBaseProperties {
+    #[serde(rename = "transactionId", default, skip_serializing_if = "Option::is_none")]
+    pub transaction_id: Option<String>,
+    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
+    pub thread_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatEventBaseProperties {
+    #[serde(rename = "recipientCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub recipient_communication_identifier: Option<CommunicationIdentifierModel>,
+    #[serde(rename = "transactionId", default, skip_serializing_if = "Option::is_none")]
+    pub transaction_id: Option<String>,
+    #[serde(rename = "threadId", default, skip_serializing_if = "Option::is_none")]
+    pub thread_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsChatThreadParticipantProperties {
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "participantCommunicationIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub participant_communication_identifier: Option<CommunicationIdentifierModel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsSmsEventBaseProperties {
+    #[serde(rename = "messageId", default, skip_serializing_if = "Option::is_none")]
+    pub message_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub from: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub to: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsSmsDeliveryAttemptProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(rename = "segmentsSucceeded", default, skip_serializing_if = "Option::is_none")]
+    pub segments_succeeded: Option<i64>,
+    #[serde(rename = "segmentsFailed", default, skip_serializing_if = "Option::is_none")]
+    pub segments_failed: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsRecordingStorageInfoProperties {
+    #[serde(rename = "recordingChunks", default, skip_serializing_if = "Vec::is_empty")]
+    pub recording_chunks: Vec<AcsRecordingChunkInfoProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AcsRecordingChunkInfoProperties {
+    #[serde(rename = "documentId", default, skip_serializing_if = "Option::is_none")]
+    pub document_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub index: Option<i64>,
+    #[serde(rename = "endReason", default, skip_serializing_if = "Option::is_none")]
+    pub end_reason: Option<String>,
+    #[serde(rename = "metadataLocation", default, skip_serializing_if = "Option::is_none")]
+    pub metadata_location: Option<String>,
+    #[serde(rename = "contentLocation", default, skip_serializing_if = "Option::is_none")]
+    pub content_location: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyInsightsPolicyStateCreatedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(rename = "policyAssignmentId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_assignment_id: Option<String>,
+    #[serde(rename = "policyDefinitionId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_definition_id: Option<String>,
+    #[serde(rename = "policyDefinitionReferenceId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_definition_reference_id: Option<String>,
+    #[serde(rename = "complianceState", default, skip_serializing_if = "Option::is_none")]
+    pub compliance_state: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "complianceReasonCode", default, skip_serializing_if = "Option::is_none")]
+    pub compliance_reason_code: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyInsightsPolicyStateChangedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(rename = "policyAssignmentId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_assignment_id: Option<String>,
+    #[serde(rename = "policyDefinitionId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_definition_id: Option<String>,
+    #[serde(rename = "policyDefinitionReferenceId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_definition_reference_id: Option<String>,
+    #[serde(rename = "complianceState", default, skip_serializing_if = "Option::is_none")]
+    pub compliance_state: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "complianceReasonCode", default, skip_serializing_if = "Option::is_none")]
+    pub compliance_reason_code: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolicyInsightsPolicyStateDeletedEventData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+    #[serde(rename = "policyAssignmentId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_assignment_id: Option<String>,
+    #[serde(rename = "policyDefinitionId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_definition_id: Option<String>,
+    #[serde(rename = "policyDefinitionReferenceId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_definition_reference_id: Option<String>,
+    #[serde(rename = "complianceState", default, skip_serializing_if = "Option::is_none")]
+    pub compliance_state: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "complianceReasonCode", default, skip_serializing_if = "Option::is_none")]
+    pub compliance_reason_code: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContainerServiceNewKubernetesVersionAvailableEventData {
+    #[serde(rename = "latestSupportedKubernetesVersion", default, skip_serializing_if = "Option::is_none")]
+    pub latest_supported_kubernetes_version: Option<String>,
+    #[serde(rename = "latestStableKubernetesVersion", default, skip_serializing_if = "Option::is_none")]
+    pub latest_stable_kubernetes_version: Option<String>,
+    #[serde(rename = "lowestMinorKubernetesVersion", default, skip_serializing_if = "Option::is_none")]
+    pub lowest_minor_kubernetes_version: Option<String>,
+    #[serde(rename = "latestPreviewKubernetesVersion", default, skip_serializing_if = "Option::is_none")]
+    pub latest_preview_kubernetes_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementUserCreatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementUserUpdatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementUserDeletedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementSubscriptionCreatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementSubscriptionUpdatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementSubscriptionDeletedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementProductCreatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementProductUpdatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementProductDeletedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementApiCreatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementApiUpdatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementApiDeletedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementApiReleaseCreatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementApiReleaseUpdatedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiManagementApiReleaseDeletedEventData {
+    #[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
+    pub resource_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommunicationIdentifierModel {
+    #[serde(rename = "rawId", default, skip_serializing_if = "Option::is_none")]
+    pub raw_id: Option<String>,
+    #[serde(rename = "communicationUser", default, skip_serializing_if = "Option::is_none")]
+    pub communication_user: Option<CommunicationUserIdentifierModel>,
+    #[serde(rename = "phoneNumber", default, skip_serializing_if = "Option::is_none")]
+    pub phone_number: Option<PhoneNumberIdentifierModel>,
+    #[serde(rename = "microsoftTeamsUser", default, skip_serializing_if = "Option::is_none")]
+    pub microsoft_teams_user: Option<MicrosoftTeamsUserIdentifierModel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommunicationUserIdentifierModel {
+    pub id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoneNumberIdentifierModel {
+    pub value: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftTeamsUserIdentifierModel {
+    #[serde(rename = "userId")]
+    pub user_id: String,
+    #[serde(rename = "isAnonymous", default, skip_serializing_if = "Option::is_none")]
+    pub is_anonymous: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cloud: Option<CommunicationCloudEnvironmentModel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum CommunicationCloudEnvironmentModel {
+    #[serde(rename = "public")]
+    Public,
+    #[serde(rename = "dod")]
+    Dod,
+    #[serde(rename = "gcch")]
+    Gcch,
+}
diff --git a/services/svc/eventgrid/src/package_2018_01/operations.rs b/services/svc/eventgrid/src/package_2018_01/operations.rs
new file mode 100644
index 0000000000..b5a4862c54
--- /dev/null
+++ b/services/svc/eventgrid/src/package_2018_01/operations.rs
@@ -0,0 +1,54 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub async fn publish_events(
+    operation_config: &crate::OperationConfig,
+    events: &Vec<&EventGridEvent>,
+) -> std::result::Result<(), publish_events::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/api/events", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(publish_events::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::POST);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(publish_events::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    let req_body = azure_core::to_json(events).map_err(publish_events::Error::SerializeError)?;
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(publish_events::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(publish_events::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => Ok(()),
+        status_code => Err(publish_events::Error::DefaultResponse { status_code }),
+    }
+}
+pub mod publish_events {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse { status_code: http::StatusCode },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
diff --git a/services/svc/graphrbac/Cargo.toml b/services/svc/graphrbac/Cargo.toml
new file mode 100644
index 0000000000..42479b6b56
--- /dev/null
+++ b/services/svc/graphrbac/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_graphrbac"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["1.6"]
+"1.6" = []
diff --git a/services/svc/graphrbac/src/lib.rs b/services/svc/graphrbac/src/lib.rs
new file mode 100644
index 0000000000..1c80606972
--- /dev/null
+++ b/services/svc/graphrbac/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "1.6")]
+mod v1_6;
+use azure_core::setters;
+#[cfg(feature = "1.6")]
+pub use v1_6::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/graphrbac/src/v1_6/mod.rs b/services/svc/graphrbac/src/v1_6/mod.rs
new file mode 100644
index 0000000000..092a3a6c97
--- /dev/null
+++ b/services/svc/graphrbac/src/v1_6/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "1.6";
diff --git a/services/svc/graphrbac/src/v1_6/models.rs b/services/svc/graphrbac/src/v1_6/models.rs
new file mode 100644
index 0000000000..479ebab98e
--- /dev/null
+++ b/services/svc/graphrbac/src/v1_6/models.rs
@@ -0,0 +1,707 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformationalUrl {
+    #[serde(rename = "termsOfService", default, skip_serializing_if = "Option::is_none")]
+    pub terms_of_service: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub marketing: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub privacy: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub support: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OAuth2Permission {
+    #[serde(rename = "adminConsentDescription", default, skip_serializing_if = "Option::is_none")]
+    pub admin_consent_description: Option<String>,
+    #[serde(rename = "adminConsentDisplayName", default, skip_serializing_if = "Option::is_none")]
+    pub admin_consent_display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "isEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_enabled: Option<bool>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "userConsentDescription", default, skip_serializing_if = "Option::is_none")]
+    pub user_consent_description: Option<String>,
+    #[serde(rename = "userConsentDisplayName", default, skip_serializing_if = "Option::is_none")]
+    pub user_consent_display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OptionalClaims {
+    #[serde(rename = "idToken", default, skip_serializing_if = "Vec::is_empty")]
+    pub id_token: Vec<OptionalClaim>,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Vec::is_empty")]
+    pub access_token: Vec<OptionalClaim>,
+    #[serde(rename = "samlToken", default, skip_serializing_if = "Vec::is_empty")]
+    pub saml_token: Vec<OptionalClaim>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OptionalClaim {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub essential: Option<bool>,
+    #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+    pub additional_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PreAuthorizedApplication {
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub permissions: Vec<PreAuthorizedApplicationPermission>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub extensions: Vec<PreAuthorizedApplicationExtension>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PreAuthorizedApplicationPermission {
+    #[serde(rename = "directAccessGrant", default, skip_serializing_if = "Option::is_none")]
+    pub direct_access_grant: Option<bool>,
+    #[serde(rename = "accessGrants", default, skip_serializing_if = "Vec::is_empty")]
+    pub access_grants: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PreAuthorizedApplicationExtension {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub conditions: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GraphError {
+    #[serde(rename = "odata.error", default, skip_serializing_if = "Option::is_none")]
+    pub odata_error: Option<OdataError>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdataError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<ErrorMessage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorMessage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DirectoryObject {
+    #[serde(rename = "objectId", default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(rename = "objectType")]
+    pub object_type: String,
+    #[serde(rename = "deletionTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub deletion_timestamp: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyCredential {
+    #[serde(rename = "startDate", default, skip_serializing_if = "Option::is_none")]
+    pub start_date: Option<String>,
+    #[serde(rename = "endDate", default, skip_serializing_if = "Option::is_none")]
+    pub end_date: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(rename = "keyId", default, skip_serializing_if = "Option::is_none")]
+    pub key_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub usage: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "customKeyIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub custom_key_identifier: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PasswordCredential {
+    #[serde(rename = "startDate", default, skip_serializing_if = "Option::is_none")]
+    pub start_date: Option<String>,
+    #[serde(rename = "endDate", default, skip_serializing_if = "Option::is_none")]
+    pub end_date: Option<String>,
+    #[serde(rename = "keyId", default, skip_serializing_if = "Option::is_none")]
+    pub key_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(rename = "customKeyIdentifier", default, skip_serializing_if = "Option::is_none")]
+    pub custom_key_identifier: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RequiredResourceAccess {
+    #[serde(rename = "resourceAccess")]
+    pub resource_access: Vec<ResourceAccess>,
+    #[serde(rename = "resourceAppId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_app_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceAccess {
+    pub id: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum GroupMembershipClaims {
+    None,
+    SecurityGroup,
+    All,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationBase {
+    #[serde(rename = "allowGuestsSignIn", default, skip_serializing_if = "Option::is_none")]
+    pub allow_guests_sign_in: Option<bool>,
+    #[serde(rename = "allowPassthroughUsers", default, skip_serializing_if = "Option::is_none")]
+    pub allow_passthrough_users: Option<bool>,
+    #[serde(rename = "appLogoUrl", default, skip_serializing_if = "Option::is_none")]
+    pub app_logo_url: Option<String>,
+    #[serde(rename = "appRoles", default, skip_serializing_if = "Vec::is_empty")]
+    pub app_roles: Vec<AppRole>,
+    #[serde(rename = "appPermissions", default, skip_serializing_if = "Vec::is_empty")]
+    pub app_permissions: Vec<String>,
+    #[serde(rename = "availableToOtherTenants", default, skip_serializing_if = "Option::is_none")]
+    pub available_to_other_tenants: Option<bool>,
+    #[serde(rename = "errorUrl", default, skip_serializing_if = "Option::is_none")]
+    pub error_url: Option<String>,
+    #[serde(rename = "groupMembershipClaims", default, skip_serializing_if = "Option::is_none")]
+    pub group_membership_claims: Option<GroupMembershipClaims>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub homepage: Option<String>,
+    #[serde(rename = "informationalUrls", default, skip_serializing_if = "Option::is_none")]
+    pub informational_urls: Option<InformationalUrl>,
+    #[serde(rename = "isDeviceOnlyAuthSupported", default, skip_serializing_if = "Option::is_none")]
+    pub is_device_only_auth_supported: Option<bool>,
+    #[serde(rename = "keyCredentials", default, skip_serializing_if = "Vec::is_empty")]
+    pub key_credentials: Vec<KeyCredential>,
+    #[serde(rename = "knownClientApplications", default, skip_serializing_if = "Vec::is_empty")]
+    pub known_client_applications: Vec<String>,
+    #[serde(rename = "logoutUrl", default, skip_serializing_if = "Option::is_none")]
+    pub logout_url: Option<String>,
+    #[serde(rename = "oauth2AllowImplicitFlow", default, skip_serializing_if = "Option::is_none")]
+    pub oauth2_allow_implicit_flow: Option<bool>,
+    #[serde(rename = "oauth2AllowUrlPathMatching", default, skip_serializing_if = "Option::is_none")]
+    pub oauth2_allow_url_path_matching: Option<bool>,
+    #[serde(rename = "oauth2Permissions", default, skip_serializing_if = "Vec::is_empty")]
+    pub oauth2_permissions: Vec<OAuth2Permission>,
+    #[serde(rename = "oauth2RequirePostResponse", default, skip_serializing_if = "Option::is_none")]
+    pub oauth2_require_post_response: Option<bool>,
+    #[serde(rename = "orgRestrictions", default, skip_serializing_if = "Vec::is_empty")]
+    pub org_restrictions: Vec<String>,
+    #[serde(rename = "optionalClaims", default, skip_serializing_if = "Option::is_none")]
+    pub optional_claims: Option<OptionalClaims>,
+    #[serde(rename = "passwordCredentials", default, skip_serializing_if = "Vec::is_empty")]
+    pub password_credentials: Vec<PasswordCredential>,
+    #[serde(rename = "preAuthorizedApplications", default, skip_serializing_if = "Vec::is_empty")]
+    pub pre_authorized_applications: Vec<PreAuthorizedApplication>,
+    #[serde(rename = "publicClient", default, skip_serializing_if = "Option::is_none")]
+    pub public_client: Option<bool>,
+    #[serde(rename = "publisherDomain", default, skip_serializing_if = "Option::is_none")]
+    pub publisher_domain: Option<String>,
+    #[serde(rename = "replyUrls", default, skip_serializing_if = "Vec::is_empty")]
+    pub reply_urls: Vec<String>,
+    #[serde(rename = "requiredResourceAccess", default, skip_serializing_if = "Vec::is_empty")]
+    pub required_resource_access: Vec<RequiredResourceAccess>,
+    #[serde(rename = "samlMetadataUrl", default, skip_serializing_if = "Option::is_none")]
+    pub saml_metadata_url: Option<String>,
+    #[serde(rename = "signInAudience", default, skip_serializing_if = "Option::is_none")]
+    pub sign_in_audience: Option<String>,
+    #[serde(rename = "wwwHomepage", default, skip_serializing_if = "Option::is_none")]
+    pub www_homepage: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationCreateParameters {
+    #[serde(flatten)]
+    pub application_base: ApplicationBase,
+    #[serde(rename = "displayName")]
+    pub display_name: String,
+    #[serde(rename = "identifierUris", default, skip_serializing_if = "Vec::is_empty")]
+    pub identifier_uris: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationUpdateParameters {
+    #[serde(flatten)]
+    pub application_base: ApplicationBase,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "identifierUris", default, skip_serializing_if = "Vec::is_empty")]
+    pub identifier_uris: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Application {
+    #[serde(flatten)]
+    pub directory_object: DirectoryObject,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "allowGuestsSignIn", default, skip_serializing_if = "Option::is_none")]
+    pub allow_guests_sign_in: Option<bool>,
+    #[serde(rename = "allowPassthroughUsers", default, skip_serializing_if = "Option::is_none")]
+    pub allow_passthrough_users: Option<bool>,
+    #[serde(rename = "appLogoUrl", default, skip_serializing_if = "Option::is_none")]
+    pub app_logo_url: Option<String>,
+    #[serde(rename = "appRoles", default, skip_serializing_if = "Vec::is_empty")]
+    pub app_roles: Vec<AppRole>,
+    #[serde(rename = "appPermissions", default, skip_serializing_if = "Vec::is_empty")]
+    pub app_permissions: Vec<String>,
+    #[serde(rename = "availableToOtherTenants", default, skip_serializing_if = "Option::is_none")]
+    pub available_to_other_tenants: Option<bool>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "errorUrl", default, skip_serializing_if = "Option::is_none")]
+    pub error_url: Option<String>,
+    #[serde(rename = "groupMembershipClaims", default, skip_serializing_if = "Option::is_none")]
+    pub group_membership_claims: Option<GroupMembershipClaims>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub homepage: Option<String>,
+    #[serde(rename = "identifierUris", default, skip_serializing_if = "Vec::is_empty")]
+    pub identifier_uris: Vec<String>,
+    #[serde(rename = "informationalUrls", default, skip_serializing_if = "Option::is_none")]
+    pub informational_urls: Option<InformationalUrl>,
+    #[serde(rename = "isDeviceOnlyAuthSupported", default, skip_serializing_if = "Option::is_none")]
+    pub is_device_only_auth_supported: Option<bool>,
+    #[serde(rename = "keyCredentials", default, skip_serializing_if = "Vec::is_empty")]
+    pub key_credentials: Vec<KeyCredential>,
+    #[serde(rename = "knownClientApplications", default, skip_serializing_if = "Vec::is_empty")]
+    pub known_client_applications: Vec<String>,
+    #[serde(rename = "logoutUrl", default, skip_serializing_if = "Option::is_none")]
+    pub logout_url: Option<String>,
+    #[serde(rename = "oauth2AllowImplicitFlow", default, skip_serializing_if = "Option::is_none")]
+    pub oauth2_allow_implicit_flow: Option<bool>,
+    #[serde(rename = "oauth2AllowUrlPathMatching", default, skip_serializing_if = "Option::is_none")]
+    pub oauth2_allow_url_path_matching: Option<bool>,
+    #[serde(rename = "oauth2Permissions", default, skip_serializing_if = "Vec::is_empty")]
+    pub oauth2_permissions: Vec<OAuth2Permission>,
+    #[serde(rename = "oauth2RequirePostResponse", default, skip_serializing_if = "Option::is_none")]
+    pub oauth2_require_post_response: Option<bool>,
+    #[serde(rename = "orgRestrictions", default, skip_serializing_if = "Vec::is_empty")]
+    pub org_restrictions: Vec<String>,
+    #[serde(rename = "optionalClaims", default, skip_serializing_if = "Option::is_none")]
+    pub optional_claims: Option<OptionalClaims>,
+    #[serde(rename = "passwordCredentials", default, skip_serializing_if = "Vec::is_empty")]
+    pub password_credentials: Vec<PasswordCredential>,
+    #[serde(rename = "preAuthorizedApplications", default, skip_serializing_if = "Vec::is_empty")]
+    pub pre_authorized_applications: Vec<PreAuthorizedApplication>,
+    #[serde(rename = "publicClient", default, skip_serializing_if = "Option::is_none")]
+    pub public_client: Option<bool>,
+    #[serde(rename = "publisherDomain", default, skip_serializing_if = "Option::is_none")]
+    pub publisher_domain: Option<String>,
+    #[serde(rename = "replyUrls", default, skip_serializing_if = "Vec::is_empty")]
+    pub reply_urls: Vec<String>,
+    #[serde(rename = "requiredResourceAccess", default, skip_serializing_if = "Vec::is_empty")]
+    pub required_resource_access: Vec<RequiredResourceAccess>,
+    #[serde(rename = "samlMetadataUrl", default, skip_serializing_if = "Option::is_none")]
+    pub saml_metadata_url: Option<String>,
+    #[serde(rename = "signInAudience", default, skip_serializing_if = "Option::is_none")]
+    pub sign_in_audience: Option<String>,
+    #[serde(rename = "wwwHomepage", default, skip_serializing_if = "Option::is_none")]
+    pub www_homepage: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<Application>,
+    #[serde(rename = "odata.nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub odata_next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipalObjectResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(rename = "odata.metadata", default, skip_serializing_if = "Option::is_none")]
+    pub odata_metadata: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppRole {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "allowedMemberTypes", default, skip_serializing_if = "Vec::is_empty")]
+    pub allowed_member_types: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "isEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AddOwnerParameters {
+    pub url: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyCredentialListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<KeyCredential>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppRoleAssignmentListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<AppRoleAssignment>,
+    #[serde(rename = "odata.nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub odata_next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppRoleAssignment {
+    #[serde(flatten)]
+    pub directory_object: DirectoryObject,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "principalDisplayName", default, skip_serializing_if = "Option::is_none")]
+    pub principal_display_name: Option<String>,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "principalType", default, skip_serializing_if = "Option::is_none")]
+    pub principal_type: Option<String>,
+    #[serde(rename = "resourceDisplayName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_display_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DirectoryObjectListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<DirectoryObject>,
+    #[serde(rename = "odata.nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub odata_next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyCredentialsUpdateParameters {
+    pub value: Vec<KeyCredential>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PasswordCredentialListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<PasswordCredential>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PasswordCredentialsUpdateParameters {
+    pub value: Vec<PasswordCredential>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GroupAddMemberParameters {
+    pub url: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GroupCreateParameters {
+    #[serde(rename = "displayName")]
+    pub display_name: String,
+    #[serde(rename = "mailEnabled")]
+    pub mail_enabled: group_create_parameters::MailEnabled,
+    #[serde(rename = "mailNickname")]
+    pub mail_nickname: String,
+    #[serde(rename = "securityEnabled")]
+    pub security_enabled: group_create_parameters::SecurityEnabled,
+}
+pub mod group_create_parameters {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum MailEnabled {}
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum SecurityEnabled {}
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdGroup {
+    #[serde(flatten)]
+    pub directory_object: DirectoryObject,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "mailEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub mail_enabled: Option<bool>,
+    #[serde(rename = "mailNickname", default, skip_serializing_if = "Option::is_none")]
+    pub mail_nickname: Option<String>,
+    #[serde(rename = "securityEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub security_enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mail: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GroupListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<AdGroup>,
+    #[serde(rename = "odata.nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub odata_next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GroupGetMemberGroupsParameters {
+    #[serde(rename = "securityEnabledOnly")]
+    pub security_enabled_only: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GroupGetMemberGroupsResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CheckGroupMembershipParameters {
+    #[serde(rename = "groupId")]
+    pub group_id: String,
+    #[serde(rename = "memberId")]
+    pub member_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CheckGroupMembershipResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipalBase {
+    #[serde(rename = "accountEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub account_enabled: Option<bool>,
+    #[serde(rename = "appRoleAssignmentRequired", default, skip_serializing_if = "Option::is_none")]
+    pub app_role_assignment_required: Option<bool>,
+    #[serde(rename = "keyCredentials", default, skip_serializing_if = "Vec::is_empty")]
+    pub key_credentials: Vec<KeyCredential>,
+    #[serde(rename = "passwordCredentials", default, skip_serializing_if = "Vec::is_empty")]
+    pub password_credentials: Vec<PasswordCredential>,
+    #[serde(rename = "servicePrincipalType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipalCreateParameters {
+    #[serde(flatten)]
+    pub service_principal_base: ServicePrincipalBase,
+    #[serde(rename = "appId")]
+    pub app_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipalUpdateParameters {
+    #[serde(flatten)]
+    pub service_principal_base: ServicePrincipalBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipal {
+    #[serde(flatten)]
+    pub directory_object: DirectoryObject,
+    #[serde(rename = "accountEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub account_enabled: Option<bool>,
+    #[serde(rename = "alternativeNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub alternative_names: Vec<String>,
+    #[serde(rename = "appDisplayName", default, skip_serializing_if = "Option::is_none")]
+    pub app_display_name: Option<String>,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appOwnerTenantId", default, skip_serializing_if = "Option::is_none")]
+    pub app_owner_tenant_id: Option<String>,
+    #[serde(rename = "appRoleAssignmentRequired", default, skip_serializing_if = "Option::is_none")]
+    pub app_role_assignment_required: Option<bool>,
+    #[serde(rename = "appRoles", default, skip_serializing_if = "Vec::is_empty")]
+    pub app_roles: Vec<AppRole>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "errorUrl", default, skip_serializing_if = "Option::is_none")]
+    pub error_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub homepage: Option<String>,
+    #[serde(rename = "keyCredentials", default, skip_serializing_if = "Vec::is_empty")]
+    pub key_credentials: Vec<KeyCredential>,
+    #[serde(rename = "logoutUrl", default, skip_serializing_if = "Option::is_none")]
+    pub logout_url: Option<String>,
+    #[serde(rename = "oauth2Permissions", default, skip_serializing_if = "Vec::is_empty")]
+    pub oauth2_permissions: Vec<OAuth2Permission>,
+    #[serde(rename = "passwordCredentials", default, skip_serializing_if = "Vec::is_empty")]
+    pub password_credentials: Vec<PasswordCredential>,
+    #[serde(rename = "preferredTokenSigningKeyThumbprint", default, skip_serializing_if = "Option::is_none")]
+    pub preferred_token_signing_key_thumbprint: Option<String>,
+    #[serde(rename = "publisherName", default, skip_serializing_if = "Option::is_none")]
+    pub publisher_name: Option<String>,
+    #[serde(rename = "replyUrls", default, skip_serializing_if = "Vec::is_empty")]
+    pub reply_urls: Vec<String>,
+    #[serde(rename = "samlMetadataUrl", default, skip_serializing_if = "Option::is_none")]
+    pub saml_metadata_url: Option<String>,
+    #[serde(rename = "servicePrincipalNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub service_principal_names: Vec<String>,
+    #[serde(rename = "servicePrincipalType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipalListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ServicePrincipal>,
+    #[serde(rename = "odata.nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub odata_next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PasswordProfile {
+    pub password: String,
+    #[serde(rename = "forceChangePasswordNextLogin", default, skip_serializing_if = "Option::is_none")]
+    pub force_change_password_next_login: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserBase {
+    #[serde(rename = "immutableId", default, skip_serializing_if = "Option::is_none")]
+    pub immutable_id: Option<String>,
+    #[serde(rename = "usageLocation", default, skip_serializing_if = "Option::is_none")]
+    pub usage_location: Option<String>,
+    #[serde(rename = "givenName", default, skip_serializing_if = "Option::is_none")]
+    pub given_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub surname: Option<String>,
+    #[serde(rename = "userType", default, skip_serializing_if = "Option::is_none")]
+    pub user_type: Option<user_base::UserType>,
+}
+pub mod user_base {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum UserType {
+        Member,
+        Guest,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserCreateParameters {
+    #[serde(flatten)]
+    pub user_base: UserBase,
+    #[serde(rename = "accountEnabled")]
+    pub account_enabled: bool,
+    #[serde(rename = "displayName")]
+    pub display_name: String,
+    #[serde(rename = "passwordProfile")]
+    pub password_profile: PasswordProfile,
+    #[serde(rename = "userPrincipalName")]
+    pub user_principal_name: String,
+    #[serde(rename = "mailNickname")]
+    pub mail_nickname: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mail: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserUpdateParameters {
+    #[serde(flatten)]
+    pub user_base: UserBase,
+    #[serde(rename = "accountEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub account_enabled: Option<bool>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "passwordProfile", default, skip_serializing_if = "Option::is_none")]
+    pub password_profile: Option<PasswordProfile>,
+    #[serde(rename = "userPrincipalName", default, skip_serializing_if = "Option::is_none")]
+    pub user_principal_name: Option<String>,
+    #[serde(rename = "mailNickname", default, skip_serializing_if = "Option::is_none")]
+    pub mail_nickname: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mail: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct User {
+    #[serde(flatten)]
+    pub directory_object: DirectoryObject,
+    #[serde(rename = "immutableId", default, skip_serializing_if = "Option::is_none")]
+    pub immutable_id: Option<String>,
+    #[serde(rename = "usageLocation", default, skip_serializing_if = "Option::is_none")]
+    pub usage_location: Option<String>,
+    #[serde(rename = "givenName", default, skip_serializing_if = "Option::is_none")]
+    pub given_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub surname: Option<String>,
+    #[serde(rename = "userType", default, skip_serializing_if = "Option::is_none")]
+    pub user_type: Option<user::UserType>,
+    #[serde(rename = "accountEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub account_enabled: Option<bool>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "userPrincipalName", default, skip_serializing_if = "Option::is_none")]
+    pub user_principal_name: Option<String>,
+    #[serde(rename = "mailNickname", default, skip_serializing_if = "Option::is_none")]
+    pub mail_nickname: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mail: Option<String>,
+    #[serde(rename = "signInNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub sign_in_names: Vec<SignInName>,
+}
+pub mod user {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum UserType {
+        Member,
+        Guest,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SignInName {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserGetMemberGroupsParameters {
+    #[serde(rename = "securityEnabledOnly")]
+    pub security_enabled_only: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserGetMemberGroupsResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<User>,
+    #[serde(rename = "odata.nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub odata_next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetObjectsParameters {
+    #[serde(rename = "objectIds", default, skip_serializing_if = "Vec::is_empty")]
+    pub object_ids: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub types: Vec<String>,
+    #[serde(rename = "includeDirectoryObjectReferences", default, skip_serializing_if = "Option::is_none")]
+    pub include_directory_object_references: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Domain {
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<String>,
+    #[serde(rename = "isDefault", default, skip_serializing_if = "Option::is_none")]
+    pub is_default: Option<bool>,
+    #[serde(rename = "isVerified", default, skip_serializing_if = "Option::is_none")]
+    pub is_verified: Option<bool>,
+    pub name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DomainListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<Domain>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OAuth2PermissionGrant {
+    #[serde(rename = "odata.type", default, skip_serializing_if = "Option::is_none")]
+    pub odata_type: Option<String>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(rename = "objectId", default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(rename = "consentType", default, skip_serializing_if = "Option::is_none")]
+    pub consent_type: Option<o_auth2_permission_grant::ConsentType>,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scope: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "expiryTime", default, skip_serializing_if = "Option::is_none")]
+    pub expiry_time: Option<String>,
+}
+pub mod o_auth2_permission_grant {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ConsentType {
+        AllPrincipals,
+        Principal,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OAuth2PermissionGrantListResult {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<OAuth2PermissionGrant>,
+    #[serde(rename = "odata.nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub odata_next_link: Option<String>,
+}
diff --git a/services/svc/graphrbac/src/v1_6/operations.rs b/services/svc/graphrbac/src/v1_6/operations.rs
new file mode 100644
index 0000000000..a485fb272b
--- /dev/null
+++ b/services/svc/graphrbac/src/v1_6/operations.rs
@@ -0,0 +1,3725 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod signed_in_user {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, tenant_id: &str) -> std::result::Result<User, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/me", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_owned_objects(
+        operation_config: &crate::OperationConfig,
+        tenant_id: &str,
+    ) -> std::result::Result<DirectoryObjectListResult, list_owned_objects::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/me/ownedObjects", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(list_owned_objects::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_owned_objects::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_owned_objects::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_owned_objects::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DirectoryObjectListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_owned_objects::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_owned_objects::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_owned_objects::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_owned_objects {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod applications {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        tenant_id: &str,
+    ) -> std::result::Result<ApplicationListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/applications", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApplicationListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        parameters: &ApplicationCreateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<Application, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/applications", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: Application =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<Application, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Application =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn patch(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        parameters: &ApplicationUpdateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), patch::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(patch::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(patch::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(patch::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(patch::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(patch::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| patch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(patch::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod patch {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_owners(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<DirectoryObjectListResult, list_owners::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}/owners",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_owners::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_owners::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_owners::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_owners::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DirectoryObjectListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_owners::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_owners::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_owners::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_owners {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_owner(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        parameters: &AddOwnerParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), add_owner::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}/$links/owners",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_owner::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_owner::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(add_owner::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_owner::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_owner::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_owner::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_owner::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_owner {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_owner(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        owner_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), remove_owner::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}/$links/owners/{}",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id,
+            owner_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_owner::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_owner::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove_owner::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_owner::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| remove_owner::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(remove_owner::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod remove_owner {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_key_credentials(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<KeyCredentialListResult, list_key_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}/keyCredentials",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_key_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_key_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_key_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_key_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: KeyCredentialListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_key_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_key_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_key_credentials::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_key_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_key_credentials(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        parameters: &KeyCredentialsUpdateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), update_key_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}/keyCredentials",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_key_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_key_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update_key_credentials::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_key_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_key_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_key_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_key_credentials::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update_key_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_password_credentials(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<PasswordCredentialListResult, list_password_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}/passwordCredentials",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_password_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_password_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_password_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_password_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PasswordCredentialListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_password_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_password_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_password_credentials::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_password_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_password_credentials(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        parameters: &PasswordCredentialsUpdateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), update_password_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/applications/{}/passwordCredentials",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_password_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_password_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update_password_credentials::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_password_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_password_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_password_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_password_credentials::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update_password_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_service_principals_id_by_app_id(
+        operation_config: &crate::OperationConfig,
+        tenant_id: &str,
+        application_id: &str,
+    ) -> std::result::Result<ServicePrincipalObjectResult, get_service_principals_id_by_app_id::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipalsByAppId/{}/objectId",
+            operation_config.base_path(),
+            tenant_id,
+            application_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_service_principals_id_by_app_id::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_service_principals_id_by_app_id::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_service_principals_id_by_app_id::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_service_principals_id_by_app_id::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ServicePrincipalObjectResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_service_principals_id_by_app_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_service_principals_id_by_app_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_service_principals_id_by_app_id::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_service_principals_id_by_app_id {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod deleted_applications {
+    use crate::models::*;
+    pub async fn restore(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<Application, restore::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/deletedApplications/{}/restore",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(restore::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(restore::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(restore::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(restore::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Application =
+                    serde_json::from_slice(rsp_body).map_err(|source| restore::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| restore::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(restore::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod restore {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        tenant_id: &str,
+    ) -> std::result::Result<ApplicationListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/deletedApplications", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApplicationListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn hard_delete(
+        operation_config: &crate::OperationConfig,
+        application_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), hard_delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/deletedApplications/{}",
+            operation_config.base_path(),
+            tenant_id,
+            application_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(hard_delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(hard_delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(hard_delete::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(hard_delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| hard_delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(hard_delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod hard_delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod groups {
+    use crate::models::*;
+    pub async fn is_member_of(
+        operation_config: &crate::OperationConfig,
+        parameters: &CheckGroupMembershipParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<CheckGroupMembershipResult, is_member_of::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/isMemberOf", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(is_member_of::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(is_member_of::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(is_member_of::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(is_member_of::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(is_member_of::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: CheckGroupMembershipResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| is_member_of::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| is_member_of::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(is_member_of::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod is_member_of {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_member(
+        operation_config: &crate::OperationConfig,
+        group_object_id: &str,
+        member_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), remove_member::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/groups/{}/$links/members/{}",
+            operation_config.base_path(),
+            tenant_id,
+            group_object_id,
+            member_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_member::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_member::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove_member::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_member::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| remove_member::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(remove_member::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod remove_member {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_member(
+        operation_config: &crate::OperationConfig,
+        group_object_id: &str,
+        parameters: &GroupAddMemberParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), add_member::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/groups/{}/$links/members",
+            operation_config.base_path(),
+            tenant_id,
+            group_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_member::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_member::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(add_member::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_member::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_member::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_member::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_member::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_member {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        tenant_id: &str,
+    ) -> std::result::Result<GroupListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/groups", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GroupListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        parameters: &GroupCreateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<AdGroup, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/groups", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdGroup =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_group_members(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<DirectoryObjectListResult, get_group_members::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/groups/{}/members", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(get_group_members::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_group_members::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_group_members::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_group_members::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DirectoryObjectListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_group_members::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_group_members::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_group_members::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_group_members {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<AdGroup, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/groups/{}", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AdGroup =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/groups/{}", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_member_groups(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        parameters: &GroupGetMemberGroupsParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<GroupGetMemberGroupsResult, get_member_groups::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/groups/{}/getMemberGroups",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_member_groups::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_member_groups::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(get_member_groups::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_member_groups::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_member_groups::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GroupGetMemberGroupsResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_member_groups::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_member_groups::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_member_groups::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_member_groups {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_owners(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<DirectoryObjectListResult, list_owners::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/groups/{}/owners", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(list_owners::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_owners::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_owners::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_owners::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DirectoryObjectListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_owners::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_owners::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_owners::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_owners {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_owner(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        parameters: &AddOwnerParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), add_owner::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/groups/{}/$links/owners", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(add_owner::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_owner::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(add_owner::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_owner::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_owner::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_owner::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_owner::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_owner {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_owner(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        owner_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), remove_owner::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/groups/{}/$links/owners/{}",
+            operation_config.base_path(),
+            tenant_id,
+            object_id,
+            owner_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_owner::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_owner::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove_owner::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_owner::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| remove_owner::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(remove_owner::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod remove_owner {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod service_principals {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        tenant_id: &str,
+    ) -> std::result::Result<ServicePrincipalListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/servicePrincipals", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ServicePrincipalListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        parameters: &ServicePrincipalCreateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<ServicePrincipal, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/servicePrincipals", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: ServicePrincipal =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<ServicePrincipal, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/servicePrincipals/{}", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ServicePrincipal =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        parameters: &ServicePrincipalUpdateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/servicePrincipals/{}", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/servicePrincipals/{}", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_app_role_assigned_to(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<AppRoleAssignmentListResult, list_app_role_assigned_to::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/appRoleAssignedTo",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_app_role_assigned_to::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_app_role_assigned_to::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_app_role_assigned_to::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_app_role_assigned_to::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AppRoleAssignmentListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_app_role_assigned_to::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_app_role_assigned_to::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_app_role_assigned_to::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_app_role_assigned_to {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_app_role_assignments(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<AppRoleAssignmentListResult, list_app_role_assignments::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/appRoleAssignments",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_app_role_assignments::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_app_role_assignments::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_app_role_assignments::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_app_role_assignments::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AppRoleAssignmentListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_app_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_app_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_app_role_assignments::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_app_role_assignments {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_owners(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<DirectoryObjectListResult, list_owners::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/owners",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_owners::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_owners::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_owners::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_owners::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DirectoryObjectListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_owners::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_owners::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_owners::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_owners {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_owner(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        parameters: &AddOwnerParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), add_owner::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/$links/owners",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_owner::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_owner::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(add_owner::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_owner::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_owner::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_owner::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_owner::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_owner {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_owner(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        owner_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), remove_owner::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/$links/owners/{}",
+            operation_config.base_path(),
+            tenant_id,
+            object_id,
+            owner_object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_owner::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_owner::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove_owner::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_owner::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| remove_owner::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(remove_owner::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod remove_owner {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_key_credentials(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<KeyCredentialListResult, list_key_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/keyCredentials",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_key_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_key_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_key_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_key_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: KeyCredentialListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_key_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_key_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_key_credentials::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_key_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_key_credentials(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        parameters: &KeyCredentialsUpdateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), update_key_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/keyCredentials",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_key_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_key_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update_key_credentials::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_key_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_key_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_key_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_key_credentials::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update_key_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_password_credentials(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<PasswordCredentialListResult, list_password_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/passwordCredentials",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_password_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_password_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_password_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_password_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PasswordCredentialListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_password_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_password_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_password_credentials::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_password_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_password_credentials(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        parameters: &PasswordCredentialsUpdateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), update_password_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/servicePrincipals/{}/passwordCredentials",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_password_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_password_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update_password_credentials::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_password_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_password_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_password_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_password_credentials::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update_password_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod users {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        expand: Option<&str>,
+        top: Option<i64>,
+        tenant_id: &str,
+    ) -> std::result::Result<UserListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/users", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        if let Some(expand) = expand {
+            url.query_pairs_mut().append_pair("$expand", expand);
+        }
+        if let Some(top) = top {
+            url.query_pairs_mut().append_pair("$top", top.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: UserListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        parameters: &UserCreateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<User, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/users", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        upn_or_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<User, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/users/{}", operation_config.base_path(), tenant_id, upn_or_object_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        upn_or_object_id: &str,
+        parameters: &UserUpdateParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<(), update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/users/{}", operation_config.base_path(), tenant_id, upn_or_object_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        upn_or_object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/users/{}", operation_config.base_path(), tenant_id, upn_or_object_id);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_member_groups(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        parameters: &UserGetMemberGroupsParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<UserGetMemberGroupsResult, get_member_groups::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/users/{}/getMemberGroups", operation_config.base_path(), tenant_id, object_id);
+        let mut url = url::Url::parse(url_str).map_err(get_member_groups::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_member_groups::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(get_member_groups::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_member_groups::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_member_groups::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: UserGetMemberGroupsResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_member_groups::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_member_groups::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_member_groups::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_member_groups {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod objects {
+    use crate::models::*;
+    pub async fn get_objects_by_object_ids(
+        operation_config: &crate::OperationConfig,
+        parameters: &GetObjectsParameters,
+        tenant_id: &str,
+    ) -> std::result::Result<DirectoryObjectListResult, get_objects_by_object_ids::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/getObjectsByObjectIds", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(get_objects_by_object_ids::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_objects_by_object_ids::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(get_objects_by_object_ids::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_objects_by_object_ids::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_objects_by_object_ids::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DirectoryObjectListResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_objects_by_object_ids::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_objects_by_object_ids::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_objects_by_object_ids {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod domains {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        tenant_id: &str,
+    ) -> std::result::Result<DomainListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/domains", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DomainListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        domain_name: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<Domain, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/domains/{}", operation_config.base_path(), tenant_id, domain_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Domain =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod o_auth2_permission_grant {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        filter: Option<&str>,
+        tenant_id: &str,
+    ) -> std::result::Result<OAuth2PermissionGrantListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/oauth2PermissionGrants", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("$filter", filter);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: OAuth2PermissionGrantListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        body: Option<&OAuth2PermissionGrant>,
+        tenant_id: &str,
+    ) -> std::result::Result<OAuth2PermissionGrant, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/{}/oauth2PermissionGrants", operation_config.base_path(), tenant_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = if let Some(body) = body {
+            azure_core::to_json(body).map_err(create::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: OAuth2PermissionGrant =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        object_id: &str,
+        tenant_id: &str,
+    ) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/{}/oauth2PermissionGrants/{}",
+            operation_config.base_path(),
+            tenant_id,
+            object_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: GraphError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::GraphError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/Cargo.toml b/services/svc/imds/Cargo.toml
new file mode 100644
index 0000000000..9f67166253
--- /dev/null
+++ b/services/svc/imds/Cargo.toml
@@ -0,0 +1,40 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_imds"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2018-10-01"]
+"package-2018-10-01" = []
+"package-2019-02-01" = []
+"package-2019-03-11" = []
+"package-2019-04-30" = []
+"package-2019-06-01" = []
+"package-2019-06-04" = []
+"package-2019-08-01" = []
+"package-2019-08-15" = []
+"package-2019-11-01" = []
+"package-2020-06-01" = []
+"package-2020-07-15" = []
+"package-2020-09-01" = []
+"package-2020-10-01" = []
+"package-2020-12-01" = []
+"package-2021-01-01" = []
+"package-2021-02-01" = []
+"package-2021-03-01" = []
+"package-2021-05-01" = []
diff --git a/services/svc/imds/src/lib.rs b/services/svc/imds/src/lib.rs
new file mode 100644
index 0000000000..a361d417d5
--- /dev/null
+++ b/services/svc/imds/src/lib.rs
@@ -0,0 +1,129 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2018-10-01")]
+mod package_2018_10_01;
+#[cfg(feature = "package-2018-10-01")]
+pub use package_2018_10_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-02-01")]
+mod package_2019_02_01;
+#[cfg(feature = "package-2019-02-01")]
+pub use package_2019_02_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-03-11")]
+mod package_2019_03_11;
+#[cfg(feature = "package-2019-03-11")]
+pub use package_2019_03_11::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-04-30")]
+mod package_2019_04_30;
+#[cfg(feature = "package-2019-04-30")]
+pub use package_2019_04_30::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-06-01")]
+mod package_2019_06_01;
+#[cfg(feature = "package-2019-06-01")]
+pub use package_2019_06_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-06-04")]
+mod package_2019_06_04;
+#[cfg(feature = "package-2019-06-04")]
+pub use package_2019_06_04::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-08-01")]
+mod package_2019_08_01;
+#[cfg(feature = "package-2019-08-01")]
+pub use package_2019_08_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-08-15")]
+mod package_2019_08_15;
+#[cfg(feature = "package-2019-08-15")]
+pub use package_2019_08_15::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-11-01")]
+mod package_2019_11_01;
+#[cfg(feature = "package-2019-11-01")]
+pub use package_2019_11_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2020-06-01")]
+mod package_2020_06_01;
+#[cfg(feature = "package-2020-06-01")]
+pub use package_2020_06_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2020-07-15")]
+mod package_2020_07_15;
+#[cfg(feature = "package-2020-07-15")]
+pub use package_2020_07_15::{models, operations, API_VERSION};
+#[cfg(feature = "package-2020-09-01")]
+mod package_2020_09_01;
+#[cfg(feature = "package-2020-09-01")]
+pub use package_2020_09_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2020-10-01")]
+mod package_2020_10_01;
+#[cfg(feature = "package-2020-10-01")]
+pub use package_2020_10_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2020-12-01")]
+mod package_2020_12_01;
+#[cfg(feature = "package-2020-12-01")]
+pub use package_2020_12_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-01-01")]
+mod package_2021_01_01;
+#[cfg(feature = "package-2021-01-01")]
+pub use package_2021_01_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-02-01")]
+mod package_2021_02_01;
+#[cfg(feature = "package-2021-02-01")]
+pub use package_2021_02_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-03-01")]
+mod package_2021_03_01;
+#[cfg(feature = "package-2021-03-01")]
+pub use package_2021_03_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-05-01")]
+mod package_2021_05_01;
+use azure_core::setters;
+#[cfg(feature = "package-2021-05-01")]
+pub use package_2021_05_01::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/imds/src/package_2018_10_01/mod.rs b/services/svc/imds/src/package_2018_10_01/mod.rs
new file mode 100644
index 0000000000..4664a4ec90
--- /dev/null
+++ b/services/svc/imds/src/package_2018_10_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2018-10-01";
diff --git a/services/svc/imds/src/package_2018_10_01/models.rs b/services/svc/imds/src/package_2018_10_01/models.rs
new file mode 100644
index 0000000000..635f07591b
--- /dev/null
+++ b/services/svc/imds/src/package_2018_10_01/models.rs
@@ -0,0 +1,197 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2018_10_01/operations.rs b/services/svc/imds/src/package_2018_10_01/operations.rs
new file mode 100644
index 0000000000..23ce1d8b3e
--- /dev/null
+++ b/services/svc/imds/src/package_2018_10_01/operations.rs
@@ -0,0 +1,496 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::BAD_REQUEST => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::BadRequest400 { value: rsp_value })
+            }
+            http::StatusCode::FORBIDDEN => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::Forbidden403 { value: rsp_value })
+            }
+            http::StatusCode::NOT_FOUND => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::NotFound404 { value: rsp_value })
+            }
+            http::StatusCode::METHOD_NOT_ALLOWED => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::MethodNotAllowed405 { value: rsp_value })
+            }
+            http::StatusCode::TOO_MANY_REQUESTS => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::TooManyRequests429 { value: rsp_value })
+            }
+            http::StatusCode::SERVICE_UNAVAILABLE => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::ServiceUnavailable503 { value: rsp_value })
+            }
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            BadRequest400 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            Forbidden403 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            NotFound404 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            MethodNotAllowed405 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            TooManyRequests429 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            ServiceUnavailable503 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::BAD_REQUEST => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::BadRequest400 { value: rsp_value })
+            }
+            http::StatusCode::FORBIDDEN => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::Forbidden403 { value: rsp_value })
+            }
+            http::StatusCode::NOT_FOUND => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::NotFound404 { value: rsp_value })
+            }
+            http::StatusCode::METHOD_NOT_ALLOWED => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::MethodNotAllowed405 { value: rsp_value })
+            }
+            http::StatusCode::TOO_MANY_REQUESTS => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::TooManyRequests429 { value: rsp_value })
+            }
+            http::StatusCode::SERVICE_UNAVAILABLE => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::ServiceUnavailable503 { value: rsp_value })
+            }
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            BadRequest400 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            Forbidden403 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            NotFound404 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            MethodNotAllowed405 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            TooManyRequests429 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            ServiceUnavailable503 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::BAD_REQUEST => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::BadRequest400 { value: rsp_value })
+            }
+            http::StatusCode::NOT_FOUND => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::NotFound404 { value: rsp_value })
+            }
+            http::StatusCode::METHOD_NOT_ALLOWED => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::MethodNotAllowed405 { value: rsp_value })
+            }
+            http::StatusCode::TOO_MANY_REQUESTS => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::TooManyRequests429 { value: rsp_value })
+            }
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            BadRequest400 { value: models::IdentityErrorResponse },
+            #[error("Error response #response_type")]
+            NotFound404 { value: models::IdentityErrorResponse },
+            #[error("Error response #response_type")]
+            MethodNotAllowed405 { value: models::IdentityErrorResponse },
+            #[error("Error response #response_type")]
+            TooManyRequests429 { value: models::IdentityErrorResponse },
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::IdentityErrorResponse },
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::BAD_REQUEST => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::BadRequest400 { value: rsp_value })
+            }
+            http::StatusCode::NOT_FOUND => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::NotFound404 { value: rsp_value })
+            }
+            http::StatusCode::METHOD_NOT_ALLOWED => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::MethodNotAllowed405 { value: rsp_value })
+            }
+            http::StatusCode::TOO_MANY_REQUESTS => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::TooManyRequests429 { value: rsp_value })
+            }
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            BadRequest400 { value: models::IdentityErrorResponse },
+            #[error("Error response #response_type")]
+            NotFound404 { value: models::IdentityErrorResponse },
+            #[error("Error response #response_type")]
+            MethodNotAllowed405 { value: models::IdentityErrorResponse },
+            #[error("Error response #response_type")]
+            TooManyRequests429 { value: models::IdentityErrorResponse },
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::IdentityErrorResponse },
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2019_02_01/mod.rs b/services/svc/imds/src/package_2019_02_01/mod.rs
new file mode 100644
index 0000000000..f5f382dd15
--- /dev/null
+++ b/services/svc/imds/src/package_2019_02_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-02-01";
diff --git a/services/svc/imds/src/package_2019_02_01/models.rs b/services/svc/imds/src/package_2019_02_01/models.rs
new file mode 100644
index 0000000000..c009f2c11d
--- /dev/null
+++ b/services/svc/imds/src/package_2019_02_01/models.rs
@@ -0,0 +1,199 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "customData", default, skip_serializing_if = "Option::is_none")]
+    pub custom_data: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2019_02_01/operations.rs b/services/svc/imds/src/package_2019_02_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2019_02_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2019_03_11/mod.rs b/services/svc/imds/src/package_2019_03_11/mod.rs
new file mode 100644
index 0000000000..3ebb67f55c
--- /dev/null
+++ b/services/svc/imds/src/package_2019_03_11/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-03-11";
diff --git a/services/svc/imds/src/package_2019_03_11/models.rs b/services/svc/imds/src/package_2019_03_11/models.rs
new file mode 100644
index 0000000000..0b958ad5d8
--- /dev/null
+++ b/services/svc/imds/src/package_2019_03_11/models.rs
@@ -0,0 +1,201 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "customData", default, skip_serializing_if = "Option::is_none")]
+    pub custom_data: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2019_03_11/operations.rs b/services/svc/imds/src/package_2019_03_11/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2019_03_11/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2019_04_30/mod.rs b/services/svc/imds/src/package_2019_04_30/mod.rs
new file mode 100644
index 0000000000..26c6f37578
--- /dev/null
+++ b/services/svc/imds/src/package_2019_04_30/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-04-30";
diff --git a/services/svc/imds/src/package_2019_04_30/models.rs b/services/svc/imds/src/package_2019_04_30/models.rs
new file mode 100644
index 0000000000..0b958ad5d8
--- /dev/null
+++ b/services/svc/imds/src/package_2019_04_30/models.rs
@@ -0,0 +1,201 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "customData", default, skip_serializing_if = "Option::is_none")]
+    pub custom_data: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2019_04_30/operations.rs b/services/svc/imds/src/package_2019_04_30/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2019_04_30/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2019_06_01/mod.rs b/services/svc/imds/src/package_2019_06_01/mod.rs
new file mode 100644
index 0000000000..0d5f520700
--- /dev/null
+++ b/services/svc/imds/src/package_2019_06_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-06-01";
diff --git a/services/svc/imds/src/package_2019_06_01/models.rs b/services/svc/imds/src/package_2019_06_01/models.rs
new file mode 100644
index 0000000000..48e184aed1
--- /dev/null
+++ b/services/svc/imds/src/package_2019_06_01/models.rs
@@ -0,0 +1,291 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2019_06_01/operations.rs b/services/svc/imds/src/package_2019_06_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2019_06_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2019_06_04/mod.rs b/services/svc/imds/src/package_2019_06_04/mod.rs
new file mode 100644
index 0000000000..62f5709b42
--- /dev/null
+++ b/services/svc/imds/src/package_2019_06_04/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-06-04";
diff --git a/services/svc/imds/src/package_2019_06_04/models.rs b/services/svc/imds/src/package_2019_06_04/models.rs
new file mode 100644
index 0000000000..f6d14b1c69
--- /dev/null
+++ b/services/svc/imds/src/package_2019_06_04/models.rs
@@ -0,0 +1,300 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2019_06_04/operations.rs b/services/svc/imds/src/package_2019_06_04/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2019_06_04/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2019_08_01/mod.rs b/services/svc/imds/src/package_2019_08_01/mod.rs
new file mode 100644
index 0000000000..c834efcfbf
--- /dev/null
+++ b/services/svc/imds/src/package_2019_08_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-08-01";
diff --git a/services/svc/imds/src/package_2019_08_01/models.rs b/services/svc/imds/src/package_2019_08_01/models.rs
new file mode 100644
index 0000000000..4d6d9784f9
--- /dev/null
+++ b/services/svc/imds/src/package_2019_08_01/models.rs
@@ -0,0 +1,307 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2019_08_01/operations.rs b/services/svc/imds/src/package_2019_08_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2019_08_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2019_08_15/mod.rs b/services/svc/imds/src/package_2019_08_15/mod.rs
new file mode 100644
index 0000000000..86e49bc241
--- /dev/null
+++ b/services/svc/imds/src/package_2019_08_15/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-08-15";
diff --git a/services/svc/imds/src/package_2019_08_15/models.rs b/services/svc/imds/src/package_2019_08_15/models.rs
new file mode 100644
index 0000000000..93625e6673
--- /dev/null
+++ b/services/svc/imds/src/package_2019_08_15/models.rs
@@ -0,0 +1,298 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2019_08_15/operations.rs b/services/svc/imds/src/package_2019_08_15/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2019_08_15/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2019_11_01/mod.rs b/services/svc/imds/src/package_2019_11_01/mod.rs
new file mode 100644
index 0000000000..f6cbc237e7
--- /dev/null
+++ b/services/svc/imds/src/package_2019_11_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-11-01";
diff --git a/services/svc/imds/src/package_2019_11_01/models.rs b/services/svc/imds/src/package_2019_11_01/models.rs
new file mode 100644
index 0000000000..93625e6673
--- /dev/null
+++ b/services/svc/imds/src/package_2019_11_01/models.rs
@@ -0,0 +1,298 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2019_11_01/operations.rs b/services/svc/imds/src/package_2019_11_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2019_11_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2020_06_01/mod.rs b/services/svc/imds/src/package_2020_06_01/mod.rs
new file mode 100644
index 0000000000..b9a2fc60cb
--- /dev/null
+++ b/services/svc/imds/src/package_2020_06_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-06-01";
diff --git a/services/svc/imds/src/package_2020_06_01/models.rs b/services/svc/imds/src/package_2020_06_01/models.rs
new file mode 100644
index 0000000000..edf169605f
--- /dev/null
+++ b/services/svc/imds/src/package_2020_06_01/models.rs
@@ -0,0 +1,318 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2020_06_01/operations.rs b/services/svc/imds/src/package_2020_06_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2020_06_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2020_07_15/mod.rs b/services/svc/imds/src/package_2020_07_15/mod.rs
new file mode 100644
index 0000000000..e4f6d9bee9
--- /dev/null
+++ b/services/svc/imds/src/package_2020_07_15/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-07-15";
diff --git a/services/svc/imds/src/package_2020_07_15/models.rs b/services/svc/imds/src/package_2020_07_15/models.rs
new file mode 100644
index 0000000000..85c02498d6
--- /dev/null
+++ b/services/svc/imds/src/package_2020_07_15/models.rs
@@ -0,0 +1,327 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osProfile", default, skip_serializing_if = "Option::is_none")]
+    pub os_profile: Option<OsProfile>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsProfile {
+    #[serde(rename = "adminUsername", default, skip_serializing_if = "Option::is_none")]
+    pub admin_username: Option<String>,
+    #[serde(rename = "computerName", default, skip_serializing_if = "Option::is_none")]
+    pub computer_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2020_07_15/operations.rs b/services/svc/imds/src/package_2020_07_15/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2020_07_15/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2020_09_01/mod.rs b/services/svc/imds/src/package_2020_09_01/mod.rs
new file mode 100644
index 0000000000..48de9849ea
--- /dev/null
+++ b/services/svc/imds/src/package_2020_09_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-09-01";
diff --git a/services/svc/imds/src/package_2020_09_01/models.rs b/services/svc/imds/src/package_2020_09_01/models.rs
new file mode 100644
index 0000000000..288850dbf5
--- /dev/null
+++ b/services/svc/imds/src/package_2020_09_01/models.rs
@@ -0,0 +1,329 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(rename = "licenseType", default, skip_serializing_if = "Option::is_none")]
+    pub license_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osProfile", default, skip_serializing_if = "Option::is_none")]
+    pub os_profile: Option<OsProfile>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsProfile {
+    #[serde(rename = "adminUsername", default, skip_serializing_if = "Option::is_none")]
+    pub admin_username: Option<String>,
+    #[serde(rename = "computerName", default, skip_serializing_if = "Option::is_none")]
+    pub computer_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2020_09_01/operations.rs b/services/svc/imds/src/package_2020_09_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2020_09_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2020_10_01/mod.rs b/services/svc/imds/src/package_2020_10_01/mod.rs
new file mode 100644
index 0000000000..1ef716874c
--- /dev/null
+++ b/services/svc/imds/src/package_2020_10_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-10-01";
diff --git a/services/svc/imds/src/package_2020_10_01/models.rs b/services/svc/imds/src/package_2020_10_01/models.rs
new file mode 100644
index 0000000000..3d255491bf
--- /dev/null
+++ b/services/svc/imds/src/package_2020_10_01/models.rs
@@ -0,0 +1,331 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(rename = "licenseType", default, skip_serializing_if = "Option::is_none")]
+    pub license_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osProfile", default, skip_serializing_if = "Option::is_none")]
+    pub os_profile: Option<OsProfile>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsProfile {
+    #[serde(rename = "adminUsername", default, skip_serializing_if = "Option::is_none")]
+    pub admin_username: Option<String>,
+    #[serde(rename = "computerName", default, skip_serializing_if = "Option::is_none")]
+    pub computer_name: Option<String>,
+    #[serde(rename = "disablePasswordAuthentication", default, skip_serializing_if = "Option::is_none")]
+    pub disable_password_authentication: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2020_10_01/operations.rs b/services/svc/imds/src/package_2020_10_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2020_10_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2020_12_01/mod.rs b/services/svc/imds/src/package_2020_12_01/mod.rs
new file mode 100644
index 0000000000..295814b1a2
--- /dev/null
+++ b/services/svc/imds/src/package_2020_12_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-12-01";
diff --git a/services/svc/imds/src/package_2020_12_01/models.rs b/services/svc/imds/src/package_2020_12_01/models.rs
new file mode 100644
index 0000000000..e39e01f381
--- /dev/null
+++ b/services/svc/imds/src/package_2020_12_01/models.rs
@@ -0,0 +1,335 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "evictionPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub eviction_policy: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(rename = "licenseType", default, skip_serializing_if = "Option::is_none")]
+    pub license_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osProfile", default, skip_serializing_if = "Option::is_none")]
+    pub os_profile: Option<OsProfile>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsProfile {
+    #[serde(rename = "adminUsername", default, skip_serializing_if = "Option::is_none")]
+    pub admin_username: Option<String>,
+    #[serde(rename = "computerName", default, skip_serializing_if = "Option::is_none")]
+    pub computer_name: Option<String>,
+    #[serde(rename = "disablePasswordAuthentication", default, skip_serializing_if = "Option::is_none")]
+    pub disable_password_authentication: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2020_12_01/operations.rs b/services/svc/imds/src/package_2020_12_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2020_12_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2021_01_01/mod.rs b/services/svc/imds/src/package_2021_01_01/mod.rs
new file mode 100644
index 0000000000..1a193f3aea
--- /dev/null
+++ b/services/svc/imds/src/package_2021_01_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-01-01";
diff --git a/services/svc/imds/src/package_2021_01_01/models.rs b/services/svc/imds/src/package_2021_01_01/models.rs
new file mode 100644
index 0000000000..1e0971b986
--- /dev/null
+++ b/services/svc/imds/src/package_2021_01_01/models.rs
@@ -0,0 +1,337 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "evictionPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub eviction_policy: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(rename = "licenseType", default, skip_serializing_if = "Option::is_none")]
+    pub license_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osProfile", default, skip_serializing_if = "Option::is_none")]
+    pub os_profile: Option<OsProfile>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(rename = "userData", default, skip_serializing_if = "Option::is_none")]
+    pub user_data: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsProfile {
+    #[serde(rename = "adminUsername", default, skip_serializing_if = "Option::is_none")]
+    pub admin_username: Option<String>,
+    #[serde(rename = "computerName", default, skip_serializing_if = "Option::is_none")]
+    pub computer_name: Option<String>,
+    #[serde(rename = "disablePasswordAuthentication", default, skip_serializing_if = "Option::is_none")]
+    pub disable_password_authentication: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2021_01_01/operations.rs b/services/svc/imds/src/package_2021_01_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2021_01_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2021_02_01/mod.rs b/services/svc/imds/src/package_2021_02_01/mod.rs
new file mode 100644
index 0000000000..f69b37d506
--- /dev/null
+++ b/services/svc/imds/src/package_2021_02_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-02-01";
diff --git a/services/svc/imds/src/package_2021_02_01/models.rs b/services/svc/imds/src/package_2021_02_01/models.rs
new file mode 100644
index 0000000000..83cd66be5d
--- /dev/null
+++ b/services/svc/imds/src/package_2021_02_01/models.rs
@@ -0,0 +1,347 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "evictionPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub eviction_policy: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(rename = "licenseType", default, skip_serializing_if = "Option::is_none")]
+    pub license_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osProfile", default, skip_serializing_if = "Option::is_none")]
+    pub os_profile: Option<OsProfile>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(rename = "userData", default, skip_serializing_if = "Option::is_none")]
+    pub user_data: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsProfile {
+    #[serde(rename = "adminUsername", default, skip_serializing_if = "Option::is_none")]
+    pub admin_username: Option<String>,
+    #[serde(rename = "computerName", default, skip_serializing_if = "Option::is_none")]
+    pub computer_name: Option<String>,
+    #[serde(rename = "disablePasswordAuthentication", default, skip_serializing_if = "Option::is_none")]
+    pub disable_password_authentication: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+    #[serde(rename = "resourceDisk", default, skip_serializing_if = "Option::is_none")]
+    pub resource_disk: Option<storage_profile::ResourceDisk>,
+}
+pub mod storage_profile {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct ResourceDisk {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub size: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2021_02_01/operations.rs b/services/svc/imds/src/package_2021_02_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2021_02_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2021_03_01/mod.rs b/services/svc/imds/src/package_2021_03_01/mod.rs
new file mode 100644
index 0000000000..22180acc9d
--- /dev/null
+++ b/services/svc/imds/src/package_2021_03_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-03-01";
diff --git a/services/svc/imds/src/package_2021_03_01/models.rs b/services/svc/imds/src/package_2021_03_01/models.rs
new file mode 100644
index 0000000000..83cd66be5d
--- /dev/null
+++ b/services/svc/imds/src/package_2021_03_01/models.rs
@@ -0,0 +1,347 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "evictionPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub eviction_policy: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(rename = "licenseType", default, skip_serializing_if = "Option::is_none")]
+    pub license_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osProfile", default, skip_serializing_if = "Option::is_none")]
+    pub os_profile: Option<OsProfile>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(rename = "userData", default, skip_serializing_if = "Option::is_none")]
+    pub user_data: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsProfile {
+    #[serde(rename = "adminUsername", default, skip_serializing_if = "Option::is_none")]
+    pub admin_username: Option<String>,
+    #[serde(rename = "computerName", default, skip_serializing_if = "Option::is_none")]
+    pub computer_name: Option<String>,
+    #[serde(rename = "disablePasswordAuthentication", default, skip_serializing_if = "Option::is_none")]
+    pub disable_password_authentication: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+    #[serde(rename = "resourceDisk", default, skip_serializing_if = "Option::is_none")]
+    pub resource_disk: Option<storage_profile::ResourceDisk>,
+}
+pub mod storage_profile {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct ResourceDisk {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub size: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2021_03_01/operations.rs b/services/svc/imds/src/package_2021_03_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2021_03_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/imds/src/package_2021_05_01/mod.rs b/services/svc/imds/src/package_2021_05_01/mod.rs
new file mode 100644
index 0000000000..940e8e4e19
--- /dev/null
+++ b/services/svc/imds/src/package_2021_05_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-05-01";
diff --git a/services/svc/imds/src/package_2021_05_01/models.rs b/services/svc/imds/src/package_2021_05_01/models.rs
new file mode 100644
index 0000000000..c58129bc12
--- /dev/null
+++ b/services/svc/imds/src/package_2021_05_01/models.rs
@@ -0,0 +1,357 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Compute {
+    #[serde(rename = "azEnvironment", default, skip_serializing_if = "Option::is_none")]
+    pub az_environment: Option<String>,
+    #[serde(rename = "evictionPolicy", default, skip_serializing_if = "Option::is_none")]
+    pub eviction_policy: Option<String>,
+    #[serde(rename = "isHostCompatibilityLayerVm", default, skip_serializing_if = "Option::is_none")]
+    pub is_host_compatibility_layer_vm: Option<String>,
+    #[serde(rename = "licenseType", default, skip_serializing_if = "Option::is_none")]
+    pub license_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(rename = "osProfile", default, skip_serializing_if = "Option::is_none")]
+    pub os_profile: Option<OsProfile>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(rename = "placementGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub placement_group_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub plan: Option<PlanProperties>,
+    #[serde(rename = "publicKeys", default, skip_serializing_if = "Vec::is_empty")]
+    pub public_keys: Vec<PublicKeysProperties>,
+    #[serde(rename = "platformFaultDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_fault_domain: Option<String>,
+    #[serde(rename = "platformUpdateDomain", default, skip_serializing_if = "Option::is_none")]
+    pub platform_update_domain: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(rename = "securityProfile", default, skip_serializing_if = "Option::is_none")]
+    pub security_profile: Option<SecurityProfile>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(rename = "storageProfile", default, skip_serializing_if = "Option::is_none")]
+    pub storage_profile: Option<StorageProfile>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<String>,
+    #[serde(rename = "tagsList", default, skip_serializing_if = "Vec::is_empty")]
+    pub tags_list: Vec<TagsProperties>,
+    #[serde(rename = "userData", default, skip_serializing_if = "Option::is_none")]
+    pub user_data: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+    #[serde(rename = "vmId", default, skip_serializing_if = "Option::is_none")]
+    pub vm_id: Option<String>,
+    #[serde(rename = "vmScaleSetName", default, skip_serializing_if = "Option::is_none")]
+    pub vm_scale_set_name: Option<String>,
+    #[serde(rename = "vmSize", default, skip_serializing_if = "Option::is_none")]
+    pub vm_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub zone: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Network {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub interface: Vec<NetworkInterface>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetworkInterface {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv4: Option<network_interface::Ipv4>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ipv6: Option<network_interface::Ipv6>,
+    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
+    pub mac_address: Option<String>,
+}
+pub mod network_interface {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv4 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv4Properties>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub subnet: Vec<SubnetProperties>,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Ipv6 {
+        #[serde(rename = "ipAddress", default, skip_serializing_if = "Vec::is_empty")]
+        pub ip_address: Vec<Ipv6Properties>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsProfile {
+    #[serde(rename = "adminUsername", default, skip_serializing_if = "Option::is_none")]
+    pub admin_username: Option<String>,
+    #[serde(rename = "computerName", default, skip_serializing_if = "Option::is_none")]
+    pub computer_name: Option<String>,
+    #[serde(rename = "disablePasswordAuthentication", default, skip_serializing_if = "Option::is_none")]
+    pub disable_password_authentication: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PlanProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub product: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PublicKeysProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "keyData", default, skip_serializing_if = "Option::is_none")]
+    pub key_data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TagsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv4Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+    #[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub public_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Ipv6Properties {
+    #[serde(rename = "privateIpAddress", default, skip_serializing_if = "Option::is_none")]
+    pub private_ip_address: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubnetProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub address: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecurityProfile {
+    #[serde(rename = "secureBootEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub secure_boot_enabled: Option<String>,
+    #[serde(rename = "virtualTpmEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_tpm_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageProfile {
+    #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
+    pub image_reference: Option<ImageReference>,
+    #[serde(rename = "osDisk", default, skip_serializing_if = "Option::is_none")]
+    pub os_disk: Option<OsDisk>,
+    #[serde(rename = "dataDisks", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_disks: Vec<DataDisk>,
+    #[serde(rename = "resourceDisk", default, skip_serializing_if = "Option::is_none")]
+    pub resource_disk: Option<storage_profile::ResourceDisk>,
+}
+pub mod storage_profile {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct ResourceDisk {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub size: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageReference {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publisher: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OsDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diffDiskSettings", default, skip_serializing_if = "Option::is_none")]
+    pub diff_disk_settings: Option<DiffDiskSettings>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(rename = "encryptionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub encryption_settings: Option<EncryptionSettings>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
+    pub os_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataDisk {
+    #[serde(rename = "bytesPerSecondThrottle", default, skip_serializing_if = "Option::is_none")]
+    pub bytes_per_second_throttle: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub caching: Option<String>,
+    #[serde(rename = "createOption", default, skip_serializing_if = "Option::is_none")]
+    pub create_option: Option<String>,
+    #[serde(rename = "diskCapacityBytes", default, skip_serializing_if = "Option::is_none")]
+    pub disk_capacity_bytes: Option<String>,
+    #[serde(rename = "diskSizeGB", default, skip_serializing_if = "Option::is_none")]
+    pub disk_size_gb: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<DiskImage>,
+    #[serde(rename = "isSharedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub is_shared_disk: Option<String>,
+    #[serde(rename = "isUltraDisk", default, skip_serializing_if = "Option::is_none")]
+    pub is_ultra_disk: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lun: Option<String>,
+    #[serde(rename = "managedDisk", default, skip_serializing_if = "Option::is_none")]
+    pub managed_disk: Option<ManagedDisk>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "opsPerSecondThrottle", default, skip_serializing_if = "Option::is_none")]
+    pub ops_per_second_throttle: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub vhd: Option<VirtualHardDisk>,
+    #[serde(rename = "writeAcceleratorEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub write_accelerator_enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiffDiskSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub option: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DiskImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "storageAccountType", default, skip_serializing_if = "Option::is_none")]
+    pub storage_account_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualHardDisk {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApplicationResponse {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Instance {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<Compute>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub network: Option<Network>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttestedData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encoding: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<identity_error_response::Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_description: Option<String>,
+}
+pub mod identity_error_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Error {
+        #[serde(rename = "invalid_request")]
+        InvalidRequest,
+        #[serde(rename = "unauthorized_client")]
+        UnauthorizedClient,
+        #[serde(rename = "access_denied")]
+        AccessDenied,
+        #[serde(rename = "unsupported_response_type")]
+        UnsupportedResponseType,
+        #[serde(rename = "invalid_scope")]
+        InvalidScope,
+        #[serde(rename = "server_error")]
+        ServerError,
+        #[serde(rename = "service_unavailable")]
+        ServiceUnavailable,
+        #[serde(rename = "bad_request")]
+        BadRequest,
+        #[serde(rename = "forbidden")]
+        Forbidden,
+        #[serde(rename = "not_found")]
+        NotFound,
+        #[serde(rename = "method_not_allowed")]
+        MethodNotAllowed,
+        #[serde(rename = "too_many_requests")]
+        TooManyRequests,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_on: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ext_expires_in: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub not_before: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_type: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub object_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msi_res_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IdentityInfoResponse {
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
diff --git a/services/svc/imds/src/package_2021_05_01/operations.rs b/services/svc/imds/src/package_2021_05_01/operations.rs
new file mode 100644
index 0000000000..6284246189
--- /dev/null
+++ b/services/svc/imds/src/package_2021_05_01/operations.rs
@@ -0,0 +1,304 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod instances {
+    use crate::models::*;
+    pub async fn get_metadata(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<Instance, get_metadata::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/instance", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_metadata::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_metadata::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_metadata::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_metadata::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Instance =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_metadata::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_metadata::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_metadata {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod attested {
+    use crate::models::*;
+    pub async fn get_document(
+        operation_config: &crate::OperationConfig,
+        nonce: Option<&str>,
+        metadata: &str,
+    ) -> std::result::Result<AttestedData, get_document::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/attested/document", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_document::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_document::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(nonce) = nonce {
+            url.query_pairs_mut().append_pair("nonce", nonce);
+        }
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_document::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_document::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AttestedData =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_document::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_document::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_document {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod identity {
+    use crate::models::*;
+    pub async fn get_token(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+        resource: &str,
+        client_id: Option<&str>,
+        object_id: Option<&str>,
+        msi_res_id: Option<&str>,
+        authority: Option<&str>,
+        bypass_cache: Option<&str>,
+    ) -> std::result::Result<IdentityTokenResponse, get_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/oauth2/token", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        url.query_pairs_mut().append_pair("resource", resource);
+        if let Some(client_id) = client_id {
+            url.query_pairs_mut().append_pair("client_id", client_id);
+        }
+        if let Some(object_id) = object_id {
+            url.query_pairs_mut().append_pair("object_id", object_id);
+        }
+        if let Some(msi_res_id) = msi_res_id {
+            url.query_pairs_mut().append_pair("msi_res_id", msi_res_id);
+        }
+        if let Some(authority) = authority {
+            url.query_pairs_mut().append_pair("authority", authority);
+        }
+        if let Some(bypass_cache) = bypass_cache {
+            url.query_pairs_mut().append_pair("bypass_cache", bypass_cache);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityTokenResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_info(
+        operation_config: &crate::OperationConfig,
+        metadata: &str,
+    ) -> std::result::Result<IdentityInfoResponse, get_info::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/identity/info", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_info::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_info::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        req_builder = req_builder.header("Metadata", metadata);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_info::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_info::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityInfoResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: IdentityErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_info::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_info::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_info {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::IdentityErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/iotcentral/Cargo.toml b/services/svc/iotcentral/Cargo.toml
new file mode 100644
index 0000000000..ba2b285716
--- /dev/null
+++ b/services/svc/iotcentral/Cargo.toml
@@ -0,0 +1,25 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_iotcentral"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-1.0"]
+"package-1.1-preview" = []
+"package-2021-04-30-preview" = []
+"package-1.0" = []
diff --git a/services/svc/iotcentral/src/lib.rs b/services/svc/iotcentral/src/lib.rs
new file mode 100644
index 0000000000..10d8735ef0
--- /dev/null
+++ b/services/svc/iotcentral/src/lib.rs
@@ -0,0 +1,69 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-1.1-preview")]
+mod package_1_1_preview;
+#[cfg(feature = "package-1.1-preview")]
+pub use package_1_1_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-04-30-preview")]
+mod package_2021_04_30_preview;
+#[cfg(feature = "package-2021-04-30-preview")]
+pub use package_2021_04_30_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-1.0")]
+mod package_1_0;
+use azure_core::setters;
+#[cfg(feature = "package-1.0")]
+pub use package_1_0::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/iotcentral/src/package_1_0/mod.rs b/services/svc/iotcentral/src/package_1_0/mod.rs
new file mode 100644
index 0000000000..cadfdca78f
--- /dev/null
+++ b/services/svc/iotcentral/src/package_1_0/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "1.0";
diff --git a/services/svc/iotcentral/src/package_1_0/models.rs b/services/svc/iotcentral/src/package_1_0/models.rs
new file mode 100644
index 0000000000..9790319a62
--- /dev/null
+++ b/services/svc/iotcentral/src/package_1_0/models.rs
@@ -0,0 +1,222 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiToken {
+    #[serde(flatten)]
+    pub permission: Permission,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expiry: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiTokenCollection {
+    pub value: Vec<ApiToken>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Attestation {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Collection {
+    pub value: Vec<serde_json::Value>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Device {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub template: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provisioned: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub simulated: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCollection {
+    pub value: Vec<Device>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCommand {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "connectionTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub connection_timeout: Option<i64>,
+    #[serde(rename = "responseTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub response_timeout: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub request: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub response: Option<serde_json::Value>,
+    #[serde(rename = "responseCode", default, skip_serializing_if = "Option::is_none")]
+    pub response_code: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCommandCollection {
+    pub value: Vec<DeviceCommand>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCredentials {
+    #[serde(rename = "idScope")]
+    pub id_scope: String,
+    #[serde(rename = "symmetricKey", default, skip_serializing_if = "Option::is_none")]
+    pub symmetric_key: Option<SymmetricKey>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub x509: Option<X509>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tpm: Option<Tpm>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceProperties {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTelemetry {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTemplate {
+    #[serde(rename = "@id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "@type")]
+    pub type_: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "capabilityModel")]
+    pub capability_model: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTemplateCollection {
+    pub value: Vec<DeviceTemplate>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EmailUser {
+    #[serde(flatten)]
+    pub user: User,
+    pub email: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Permission {
+    pub roles: Vec<RoleAssignment>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Role {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignment {
+    pub role: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleCollection {
+    pub value: Vec<Role>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipalUser {
+    #[serde(flatten)]
+    pub user: User,
+    #[serde(rename = "tenantId")]
+    pub tenant_id: String,
+    #[serde(rename = "objectId")]
+    pub object_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SymmetricKey {
+    #[serde(rename = "primaryKey")]
+    pub primary_key: String,
+    #[serde(rename = "secondaryKey")]
+    pub secondary_key: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SymmetricKeyAttestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    #[serde(rename = "symmetricKey")]
+    pub symmetric_key: SymmetricKey,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Tpm {
+    #[serde(rename = "endorsementKey")]
+    pub endorsement_key: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TpmAttestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    pub tpm: Tpm,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct User {
+    #[serde(flatten)]
+    pub permission: Permission,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserCollection {
+    pub value: Vec<User>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509 {
+    #[serde(rename = "clientCertificates", default, skip_serializing_if = "Option::is_none")]
+    pub client_certificates: Option<X509Certificates>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Attestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    pub x509: X509,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Certificate {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub certificate: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<X509CertificateInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509CertificateInfo {
+    #[serde(rename = "sha1Thumbprint")]
+    pub sha1_thumbprint: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Certificates {
+    pub primary: X509Certificate,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub secondary: Option<X509Certificate>,
+}
diff --git a/services/svc/iotcentral/src/package_1_0/operations.rs b/services/svc/iotcentral/src/package_1_0/operations.rs
new file mode 100644
index 0000000000..580b4dfe48
--- /dev/null
+++ b/services/svc/iotcentral/src/package_1_0/operations.rs
@@ -0,0 +1,3278 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod api_tokens {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<ApiTokenCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiTokenCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, token_id: &str) -> std::result::Result<ApiToken, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiToken =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        token_id: &str,
+        body: &ApiToken,
+    ) -> std::result::Result<ApiToken, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiToken =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, token_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod device_templates {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<DeviceTemplateCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplateCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+    ) -> std::result::Result<DeviceTemplate, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+        body: &DeviceTemplate,
+    ) -> std::result::Result<DeviceTemplate, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceTemplate, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, device_template_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod devices {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<DeviceCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, device_id: &str) -> std::result::Result<Device, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &Device,
+    ) -> std::result::Result<Device, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<Device, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, device_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Attestation, get_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &Attestation,
+    ) -> std::result::Result<Attestation, create_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(create_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_attestation::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<Attestation, update_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_attestation::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<(), remove_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(remove_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/commands/{}", operation_config.base_path(), device_id, command_name);
+        let mut url = url::Url::parse(url_str).map_err(get_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/commands/{}", operation_config.base_path(), device_id, command_name);
+        let mut url = url::Url::parse(url_str).map_err(run_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand =
+                    serde_json::from_slice(rsp_body).map_err(|source| run_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_components(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Collection, list_components::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/components", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(list_components::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_components::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_components::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_components::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_components::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_components::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_components {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_component_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_component_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_component_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_component_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_component_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_component_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(run_component_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_component_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_component_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_component_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_component_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_component_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_credentials(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<DeviceCredentials, get_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/credentials", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCredentials = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_credentials::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_modules(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Collection, list_modules::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/modules", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(list_modules::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_modules::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_modules::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_modules::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_modules::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_modules::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_modules {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_module_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_module_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_module_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_module_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_module_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_module_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_module_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_module_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_module_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_module_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_module_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_module_components(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+    ) -> std::result::Result<Collection, list_module_components::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_module_components::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_module_components::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_module_components::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_module_components::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_module_components::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_module_components::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_module_components {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_module_component_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_module_component_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_module_component_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_module_component_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_module_component_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_module_component_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(run_module_component_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_module_component_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_module_component_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_module_component_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_module_component_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_module_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_module_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_module_component_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_module_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_module_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_module_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<DeviceProperties, get_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(replace_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(replace_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod roles {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<RoleCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roles", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, role_id: &str) -> std::result::Result<Role, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roles/{}", operation_config.base_path(), role_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Role =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod users {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<UserCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: UserCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, user_id: &str) -> std::result::Result<User, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(operation_config: &crate::OperationConfig, user_id: &str, body: &User) -> std::result::Result<User, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        user_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<User, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, user_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/iotcentral/src/package_1_1_preview/mod.rs b/services/svc/iotcentral/src/package_1_1_preview/mod.rs
new file mode 100644
index 0000000000..5a1fde79da
--- /dev/null
+++ b/services/svc/iotcentral/src/package_1_1_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "1.1-preview";
diff --git a/services/svc/iotcentral/src/package_1_1_preview/models.rs b/services/svc/iotcentral/src/package_1_1_preview/models.rs
new file mode 100644
index 0000000000..bda17e9fed
--- /dev/null
+++ b/services/svc/iotcentral/src/package_1_1_preview/models.rs
@@ -0,0 +1,389 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdGroupUser {
+    #[serde(flatten)]
+    pub user: User,
+    #[serde(rename = "tenantId")]
+    pub tenant_id: String,
+    #[serde(rename = "objectId")]
+    pub object_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiToken {
+    #[serde(flatten)]
+    pub permission: Permission,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expiry: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiTokenCollection {
+    pub value: Vec<ApiToken>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Attestation {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudPropertyJobData {
+    #[serde(flatten)]
+    pub job_data: JobData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Collection {
+    pub value: Vec<serde_json::Value>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommandJobData {
+    #[serde(flatten)]
+    pub job_data: JobData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Device {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub template: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provisioned: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub simulated: Option<bool>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub organizations: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCollection {
+    pub value: Vec<Device>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCommand {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "connectionTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub connection_timeout: Option<i64>,
+    #[serde(rename = "responseTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub response_timeout: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub request: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub response: Option<serde_json::Value>,
+    #[serde(rename = "responseCode", default, skip_serializing_if = "Option::is_none")]
+    pub response_code: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCommandCollection {
+    pub value: Vec<DeviceCommand>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCredentials {
+    #[serde(rename = "idScope")]
+    pub id_scope: String,
+    #[serde(rename = "symmetricKey", default, skip_serializing_if = "Option::is_none")]
+    pub symmetric_key: Option<SymmetricKey>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub x509: Option<X509>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tpm: Option<Tpm>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceGroup {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub organizations: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceGroupCollection {
+    pub value: Vec<DeviceGroup>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceProperties {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTelemetry {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTemplate {
+    #[serde(rename = "@id", default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "@type")]
+    pub type_: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "capabilityModel")]
+    pub capability_model: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTemplateCollection {
+    pub value: Vec<DeviceTemplate>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EmailUser {
+    #[serde(flatten)]
+    pub user: User,
+    pub email: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileUpload {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub account: Option<String>,
+    #[serde(rename = "connectionString")]
+    pub connection_string: String,
+    pub container: String,
+    #[serde(rename = "sasTtl", default, skip_serializing_if = "Option::is_none")]
+    pub sas_ttl: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<file_upload::State>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+}
+pub mod file_upload {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        #[serde(rename = "pending")]
+        Pending,
+        #[serde(rename = "updating")]
+        Updating,
+        #[serde(rename = "deleting")]
+        Deleting,
+        #[serde(rename = "succeeded")]
+        Succeeded,
+        #[serde(rename = "failed")]
+        Failed,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Job {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub group: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub batch: Option<JobBatch>,
+    #[serde(rename = "cancellationThreshold", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_threshold: Option<JobCancellationThreshold>,
+    pub data: Vec<JobData>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobBatch {
+    #[serde(rename = "type")]
+    pub type_: job_batch::Type,
+    pub value: f64,
+}
+pub mod job_batch {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "number")]
+        Number,
+        #[serde(rename = "percentage")]
+        Percentage,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobCancellationThreshold {
+    #[serde(rename = "type")]
+    pub type_: job_cancellation_threshold::Type,
+    pub value: f64,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub batch: Option<bool>,
+}
+pub mod job_cancellation_threshold {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "number")]
+        Number,
+        #[serde(rename = "percentage")]
+        Percentage,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobCollection {
+    pub value: Vec<Job>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobData {
+    #[serde(rename = "type")]
+    pub type_: String,
+    pub target: String,
+    pub path: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDeviceStatus {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDeviceStatusCollection {
+    pub value: Vec<JobDeviceStatus>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Organization {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parent: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrganizationCollection {
+    pub value: Vec<Organization>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Permission {
+    pub roles: Vec<RoleAssignment>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PropertyJobData {
+    #[serde(flatten)]
+    pub job_data: JobData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Role {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignment {
+    pub role: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub organization: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleCollection {
+    pub value: Vec<Role>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipalUser {
+    #[serde(flatten)]
+    pub user: User,
+    #[serde(rename = "tenantId")]
+    pub tenant_id: String,
+    #[serde(rename = "objectId")]
+    pub object_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SymmetricKey {
+    #[serde(rename = "primaryKey")]
+    pub primary_key: String,
+    #[serde(rename = "secondaryKey")]
+    pub secondary_key: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SymmetricKeyAttestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    #[serde(rename = "symmetricKey")]
+    pub symmetric_key: SymmetricKey,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Tpm {
+    #[serde(rename = "endorsementKey")]
+    pub endorsement_key: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TpmAttestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    pub tpm: Tpm,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct User {
+    #[serde(flatten)]
+    pub permission: Permission,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserCollection {
+    pub value: Vec<User>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509 {
+    #[serde(rename = "clientCertificates", default, skip_serializing_if = "Option::is_none")]
+    pub client_certificates: Option<X509Certificates>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Attestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    pub x509: X509,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Certificate {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub certificate: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<X509CertificateInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509CertificateInfo {
+    #[serde(rename = "sha1Thumbprint")]
+    pub sha1_thumbprint: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Certificates {
+    pub primary: X509Certificate,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub secondary: Option<X509Certificate>,
+}
diff --git a/services/svc/iotcentral/src/package_1_1_preview/operations.rs b/services/svc/iotcentral/src/package_1_1_preview/operations.rs
new file mode 100644
index 0000000000..9d7a6c7685
--- /dev/null
+++ b/services/svc/iotcentral/src/package_1_1_preview/operations.rs
@@ -0,0 +1,4203 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod api_tokens {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<ApiTokenCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiTokenCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, token_id: &str) -> std::result::Result<ApiToken, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiToken =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        token_id: &str,
+        body: &ApiToken,
+    ) -> std::result::Result<ApiToken, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiToken =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, token_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod device_groups {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<DeviceGroupCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceGroups", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceGroupCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod device_templates {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<DeviceTemplateCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplateCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+    ) -> std::result::Result<DeviceTemplate, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+        body: &DeviceTemplate,
+    ) -> std::result::Result<DeviceTemplate, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceTemplate, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, device_template_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod devices {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<DeviceCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, device_id: &str) -> std::result::Result<Device, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &Device,
+    ) -> std::result::Result<Device, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<Device, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, device_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Attestation, get_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &Attestation,
+    ) -> std::result::Result<Attestation, create_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(create_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_attestation::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<Attestation, update_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_attestation::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<(), remove_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(remove_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/commands/{}", operation_config.base_path(), device_id, command_name);
+        let mut url = url::Url::parse(url_str).map_err(get_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/commands/{}", operation_config.base_path(), device_id, command_name);
+        let mut url = url::Url::parse(url_str).map_err(run_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand =
+                    serde_json::from_slice(rsp_body).map_err(|source| run_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_components(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Collection, list_components::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/components", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(list_components::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_components::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_components::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_components::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_components::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_components::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_components {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_component_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_component_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_component_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_component_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_component_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_component_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(run_component_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_component_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_component_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_component_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_component_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_component_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_credentials(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<DeviceCredentials, get_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/credentials", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCredentials = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_credentials::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_modules(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Collection, list_modules::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/modules", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(list_modules::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_modules::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_modules::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_modules::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_modules::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_modules::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_modules {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_module_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_module_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_module_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_module_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_module_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_module_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_module_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_module_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_module_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_module_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_module_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_module_components(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+    ) -> std::result::Result<Collection, list_module_components::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_module_components::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_module_components::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_module_components::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_module_components::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_module_components::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_module_components::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_module_components {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_module_component_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_module_component_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_module_component_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_module_component_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_module_component_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_module_component_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(run_module_component_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_module_component_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_module_component_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_module_component_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_module_component_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_module_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_module_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_module_component_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_module_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_module_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_module_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<DeviceProperties, get_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(replace_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(replace_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod file_uploads {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig) -> std::result::Result<FileUpload, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/fileUploads", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: FileUpload =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(operation_config: &crate::OperationConfig, body: &FileUpload) -> std::result::Result<FileUpload, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/fileUploads", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: FileUpload =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        body: &serde_json::Value,
+    ) -> std::result::Result<FileUpload, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/fileUploads", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: FileUpload =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/fileUploads", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod jobs {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<JobCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, job_id: &str) -> std::result::Result<Job, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Job =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(operation_config: &crate::OperationConfig, job_id: &str, body: &Job) -> std::result::Result<Job, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Job =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_devices(
+        operation_config: &crate::OperationConfig,
+        job_id: &str,
+    ) -> std::result::Result<JobDeviceStatusCollection, get_devices::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/devices", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(get_devices::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_devices::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_devices::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_devices::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDeviceStatusCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_devices::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_devices::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_devices {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rerun(operation_config: &crate::OperationConfig, job_id: &str, rerun_id: &str) -> std::result::Result<Job, rerun::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/rerun/{}", operation_config.base_path(), job_id, rerun_id);
+        let mut url = url::Url::parse(url_str).map_err(rerun::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rerun::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rerun::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(rerun::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Job =
+                    serde_json::from_slice(rsp_body).map_err(|source| rerun::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(rerun::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod rerun {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn resume(operation_config: &crate::OperationConfig, job_id: &str) -> std::result::Result<(), resume::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/resume", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(resume::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(resume::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(resume::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(resume::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(resume::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod resume {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn stop(operation_config: &crate::OperationConfig, job_id: &str) -> std::result::Result<(), stop::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/stop", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(stop::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(stop::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(stop::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(stop::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(stop::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod stop {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod organizations {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<OrganizationCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/organizations", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: OrganizationCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, organization_id: &str) -> std::result::Result<Organization, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/organizations/{}", operation_config.base_path(), organization_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Organization =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        organization_id: &str,
+        body: &Organization,
+    ) -> std::result::Result<Organization, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/organizations/{}", operation_config.base_path(), organization_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Organization =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        organization_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<Organization, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/organizations/{}", operation_config.base_path(), organization_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Organization =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, organization_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/organizations/{}", operation_config.base_path(), organization_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod roles {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<RoleCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roles", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, role_id: &str) -> std::result::Result<Role, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roles/{}", operation_config.base_path(), role_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Role =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod users {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<UserCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: UserCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, user_id: &str) -> std::result::Result<User, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(operation_config: &crate::OperationConfig, user_id: &str, body: &User) -> std::result::Result<User, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        user_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<User, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, user_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/iotcentral/src/package_2021_04_30_preview/mod.rs b/services/svc/iotcentral/src/package_2021_04_30_preview/mod.rs
new file mode 100644
index 0000000000..4deeb20ed9
--- /dev/null
+++ b/services/svc/iotcentral/src/package_2021_04_30_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-04-30-preview";
diff --git a/services/svc/iotcentral/src/package_2021_04_30_preview/models.rs b/services/svc/iotcentral/src/package_2021_04_30_preview/models.rs
new file mode 100644
index 0000000000..9a48dcb3a6
--- /dev/null
+++ b/services/svc/iotcentral/src/package_2021_04_30_preview/models.rs
@@ -0,0 +1,387 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdGroupUser {
+    #[serde(flatten)]
+    pub user: User,
+    #[serde(rename = "tenantId")]
+    pub tenant_id: String,
+    #[serde(rename = "objectId")]
+    pub object_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiToken {
+    #[serde(flatten)]
+    pub permission: Permission,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expiry: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ApiTokenCollection {
+    pub value: Vec<ApiToken>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Attestation {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudPropertyJobData {
+    #[serde(flatten)]
+    pub job_data: JobData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Collection {
+    pub value: Vec<serde_json::Value>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommandJobData {
+    #[serde(flatten)]
+    pub job_data: JobData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContinuousDataExport {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    pub endpoint: Endpoint,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    pub enabled: bool,
+    pub sources: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ContinuousDataExportCollection {
+    pub value: Vec<ContinuousDataExport>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Device {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(rename = "instanceOf", default, skip_serializing_if = "Option::is_none")]
+    pub instance_of: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub approved: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provisioned: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub simulated: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCloudProperties {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCollection {
+    pub value: Vec<Device>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCommand {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "connectionTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub connection_timeout: Option<i64>,
+    #[serde(rename = "responseTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub response_timeout: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub request: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub response: Option<serde_json::Value>,
+    #[serde(rename = "responseCode", default, skip_serializing_if = "Option::is_none")]
+    pub response_code: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCommandCollection {
+    pub value: Vec<DeviceCommand>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceCredentials {
+    #[serde(rename = "idScope")]
+    pub id_scope: String,
+    #[serde(rename = "symmetricKey", default, skip_serializing_if = "Option::is_none")]
+    pub symmetric_key: Option<SymmetricKey>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub x509: Option<X509>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tpm: Option<Tpm>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceGroup {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceGroupCollection {
+    pub value: Vec<DeviceGroup>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceProperties {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTelemetry {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTemplate {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub types: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "capabilityModel")]
+    pub capability_model: serde_json::Value,
+    #[serde(rename = "solutionModel", default, skip_serializing_if = "Option::is_none")]
+    pub solution_model: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeviceTemplateCollection {
+    pub value: Vec<DeviceTemplate>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EmailUser {
+    #[serde(flatten)]
+    pub user: User,
+    pub email: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Endpoint {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "connectionString")]
+    pub connection_string: String,
+    pub name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventHubsEndpoint {
+    #[serde(flatten)]
+    pub endpoint: Endpoint,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Job {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub group: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub batch: Option<JobBatch>,
+    #[serde(rename = "cancellationThreshold", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_threshold: Option<JobCancellationThreshold>,
+    pub data: Vec<JobData>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobBatch {
+    #[serde(rename = "type")]
+    pub type_: job_batch::Type,
+    pub value: f64,
+}
+pub mod job_batch {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "number")]
+        Number,
+        #[serde(rename = "percentage")]
+        Percentage,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobCancellationThreshold {
+    #[serde(rename = "type")]
+    pub type_: job_cancellation_threshold::Type,
+    pub value: f64,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub batch: Option<bool>,
+}
+pub mod job_cancellation_threshold {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "number")]
+        Number,
+        #[serde(rename = "percentage")]
+        Percentage,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobCollection {
+    pub value: Vec<Job>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobData {
+    #[serde(rename = "type")]
+    pub type_: String,
+    pub target: String,
+    pub path: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDeviceStatus {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDeviceStatusCollection {
+    pub value: Vec<JobDeviceStatus>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Permission {
+    pub roles: Vec<RoleAssignment>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PropertyJobData {
+    #[serde(flatten)]
+    pub job_data: JobData,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Role {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignment {
+    pub role: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleCollection {
+    pub value: Vec<Role>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceBusQueueEndpoint {
+    #[serde(flatten)]
+    pub endpoint: Endpoint,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceBusTopicEndpoint {
+    #[serde(flatten)]
+    pub endpoint: Endpoint,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServicePrincipalUser {
+    #[serde(flatten)]
+    pub user: User,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StorageEndpoint {
+    #[serde(flatten)]
+    pub endpoint: Endpoint,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SymmetricKey {
+    #[serde(rename = "primaryKey")]
+    pub primary_key: String,
+    #[serde(rename = "secondaryKey")]
+    pub secondary_key: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SymmetricKeyAttestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    #[serde(rename = "symmetricKey")]
+    pub symmetric_key: SymmetricKey,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Tpm {
+    #[serde(rename = "endorsementKey")]
+    pub endorsement_key: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TpmAttestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    pub tpm: Tpm,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct User {
+    #[serde(flatten)]
+    pub permission: Permission,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserCollection {
+    pub value: Vec<User>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509 {
+    #[serde(rename = "clientCertificates", default, skip_serializing_if = "Option::is_none")]
+    pub client_certificates: Option<X509Certificates>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Attestation {
+    #[serde(flatten)]
+    pub attestation: Attestation,
+    pub x509: X509,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Certificate {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub certificate: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<X509CertificateInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509CertificateInfo {
+    #[serde(rename = "sha1Thumbprint")]
+    pub sha1_thumbprint: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct X509Certificates {
+    pub primary: X509Certificate,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub secondary: Option<X509Certificate>,
+}
diff --git a/services/svc/iotcentral/src/package_2021_04_30_preview/operations.rs b/services/svc/iotcentral/src/package_2021_04_30_preview/operations.rs
new file mode 100644
index 0000000000..f41ec33dc1
--- /dev/null
+++ b/services/svc/iotcentral/src/package_2021_04_30_preview/operations.rs
@@ -0,0 +1,4296 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod api_tokens {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<ApiTokenCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiTokenCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, token_id: &str) -> std::result::Result<ApiToken, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiToken =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        token_id: &str,
+        body: &ApiToken,
+    ) -> std::result::Result<ApiToken, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ApiToken =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, token_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/apiTokens/{}", operation_config.base_path(), token_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod continuous_data_exports {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<ContinuousDataExportCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/continuousDataExports", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ContinuousDataExportCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, export_id: &str) -> std::result::Result<ContinuousDataExport, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/continuousDataExports/{}", operation_config.base_path(), export_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ContinuousDataExport =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        export_id: &str,
+        body: &ContinuousDataExport,
+    ) -> std::result::Result<ContinuousDataExport, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/continuousDataExports/{}", operation_config.base_path(), export_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ContinuousDataExport =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        export_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<ContinuousDataExport, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/continuousDataExports/{}", operation_config.base_path(), export_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ContinuousDataExport =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, export_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/continuousDataExports/{}", operation_config.base_path(), export_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod device_groups {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<DeviceGroupCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceGroups", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceGroupCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod device_templates {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<DeviceTemplateCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplateCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+    ) -> std::result::Result<DeviceTemplate, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+        body: &DeviceTemplate,
+    ) -> std::result::Result<DeviceTemplate, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceTemplate, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, device_template_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_devices(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+    ) -> std::result::Result<DeviceCollection, list_devices::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}/devices", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(list_devices::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_devices::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_devices::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_devices::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_devices::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_devices::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_devices {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_merged(
+        operation_config: &crate::OperationConfig,
+        device_template_id: &str,
+    ) -> std::result::Result<DeviceTemplate, get_merged::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deviceTemplates/{}/merged", operation_config.base_path(), device_template_id);
+        let mut url = url::Url::parse(url_str).map_err(get_merged::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_merged::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_merged::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_merged::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTemplate =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_merged::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_merged::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_merged {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod devices {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<DeviceCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, device_id: &str) -> std::result::Result<Device, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &Device,
+    ) -> std::result::Result<Device, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<Device, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Device =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, device_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Attestation, get_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &Attestation,
+    ) -> std::result::Result<Attestation, create_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(create_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_attestation::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<Attestation, update_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_attestation::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Attestation = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_attestation::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_attestation(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<(), remove_attestation::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/attestation", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(remove_attestation::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_attestation::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove_attestation::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_attestation::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove_attestation::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove_attestation {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_cloud_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<DeviceCloudProperties, get_cloud_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/cloudProperties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_cloud_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_cloud_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_cloud_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_cloud_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCloudProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_cloud_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_cloud_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_cloud_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_cloud_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &DeviceCloudProperties,
+    ) -> std::result::Result<DeviceCloudProperties, replace_cloud_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/cloudProperties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(replace_cloud_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_cloud_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_cloud_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_cloud_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_cloud_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCloudProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_cloud_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_cloud_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_cloud_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_cloud_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceCloudProperties, update_cloud_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/cloudProperties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update_cloud_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_cloud_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_cloud_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_cloud_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_cloud_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCloudProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_cloud_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_cloud_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_cloud_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/commands/{}", operation_config.base_path(), device_id, command_name);
+        let mut url = url::Url::parse(url_str).map_err(get_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/commands/{}", operation_config.base_path(), device_id, command_name);
+        let mut url = url::Url::parse(url_str).map_err(run_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand =
+                    serde_json::from_slice(rsp_body).map_err(|source| run_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_components(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Collection, list_components::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/components", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(list_components::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_components::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_components::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_components::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_components::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_components::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_components {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_component_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_component_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_component_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_component_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_component_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_component_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(run_component_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_component_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_component_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_component_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_component_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_component_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        component_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_component_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/components/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            component_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_component_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_component_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_component_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_component_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_component_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_component_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_component_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_credentials(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<DeviceCredentials, get_credentials::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/credentials", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_credentials::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_credentials::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_credentials::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_credentials::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCredentials = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_credentials::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_credentials::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_credentials {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_modules(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<Collection, list_modules::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/modules", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(list_modules::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_modules::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_modules::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_modules::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_modules::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_modules::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_modules {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_module_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_module_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_module_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_module_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_module_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_module_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_module_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_module_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_module_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_module_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_module_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_module_components(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+    ) -> std::result::Result<Collection, list_module_components::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_module_components::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_module_components::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_module_components::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_module_components::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Collection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_module_components::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_module_components::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_module_components {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_command_history(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        command_name: &str,
+    ) -> std::result::Result<DeviceCommandCollection, get_module_component_command_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_command_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_command_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_command_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_command_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommandCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_command_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_command_history::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_command_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn run_module_component_command(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        command_name: &str,
+        body: &DeviceCommand,
+    ) -> std::result::Result<DeviceCommand, run_module_component_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/commands/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            command_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_module_component_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_module_component_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(run_module_component_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(run_module_component_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_module_component_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceCommand = serde_json::from_slice(rsp_body)
+                    .map_err(|source| run_module_component_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(run_module_component_command::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod run_module_component_command {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_module_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_module_component_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_module_component_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_module_component_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_module_component_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_module_component_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_module_component_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_module_component_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_module_component_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_module_component_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_module_component_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_component_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        component_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_module_component_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/components/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            component_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_component_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_component_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_component_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_component_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_component_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_component_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_component_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+    ) -> std::result::Result<DeviceProperties, get_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(replace_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_module_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(replace_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_module_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_module_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/properties",
+            operation_config.base_path(),
+            device_id,
+            module_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(update_module_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_module_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_module_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(update_module_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_module_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_module_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_module_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_module_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_module_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        module_name: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_module_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/modules/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            module_name,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_module_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_module_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_module_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_module_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_module_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_module_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_module_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+    ) -> std::result::Result<DeviceProperties, get_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(get_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn replace_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &DeviceProperties,
+    ) -> std::result::Result<DeviceProperties, replace_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(replace_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(replace_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(replace_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(replace_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(replace_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| replace_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(replace_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod replace_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_properties(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<DeviceProperties, update_properties::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/devices/{}/properties", operation_config.base_path(), device_id);
+        let mut url = url::Url::parse(url_str).map_err(update_properties::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_properties::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_properties::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_properties::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_properties::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceProperties = serde_json::from_slice(rsp_body)
+                    .map_err(|source| update_properties::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_properties::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_properties {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_telemetry_value(
+        operation_config: &crate::OperationConfig,
+        device_id: &str,
+        telemetry_name: &str,
+    ) -> std::result::Result<DeviceTelemetry, get_telemetry_value::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/devices/{}/telemetry/{}",
+            operation_config.base_path(),
+            device_id,
+            telemetry_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_telemetry_value::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_telemetry_value::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_telemetry_value::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_telemetry_value::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DeviceTelemetry = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_telemetry_value::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_telemetry_value::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_telemetry_value {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod jobs {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<JobCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, job_id: &str) -> std::result::Result<Job, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Job =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(operation_config: &crate::OperationConfig, job_id: &str, body: &Job) -> std::result::Result<Job, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Job =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_devices(
+        operation_config: &crate::OperationConfig,
+        job_id: &str,
+    ) -> std::result::Result<JobDeviceStatusCollection, get_devices::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/devices", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(get_devices::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_devices::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_devices::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_devices::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDeviceStatusCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_devices::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_devices::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_devices {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rerun(operation_config: &crate::OperationConfig, job_id: &str, rerun_id: &str) -> std::result::Result<Job, rerun::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/rerun/{}", operation_config.base_path(), job_id, rerun_id);
+        let mut url = url::Url::parse(url_str).map_err(rerun::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rerun::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rerun::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(rerun::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Job =
+                    serde_json::from_slice(rsp_body).map_err(|source| rerun::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(rerun::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod rerun {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn resume(operation_config: &crate::OperationConfig, job_id: &str) -> std::result::Result<(), resume::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/resume", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(resume::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(resume::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(resume::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(resume::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(resume::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod resume {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn stop(operation_config: &crate::OperationConfig, job_id: &str) -> std::result::Result<(), stop::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/jobs/{}/stop", operation_config.base_path(), job_id);
+        let mut url = url::Url::parse(url_str).map_err(stop::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(stop::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(stop::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(stop::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(stop::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod stop {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod roles {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<RoleCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roles", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, role_id: &str) -> std::result::Result<Role, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roles/{}", operation_config.base_path(), role_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Role =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod users {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<UserCollection, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: UserCollection =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, user_id: &str) -> std::result::Result<User, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(operation_config: &crate::OperationConfig, user_id: &str, body: &User) -> std::result::Result<User, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        user_id: &str,
+        body: &serde_json::Value,
+    ) -> std::result::Result<User, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: User =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove(operation_config: &crate::OperationConfig, user_id: &str) -> std::result::Result<(), remove::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/users/{}", operation_config.base_path(), user_id);
+        let mut url = url::Url::parse(url_str).map_err(remove::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(remove::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(remove::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(remove::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod remove {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/mediaservices/Cargo.toml b/services/svc/mediaservices/Cargo.toml
new file mode 100644
index 0000000000..10ccd9d836
--- /dev/null
+++ b/services/svc/mediaservices/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_mediaservices"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-lva-1-0-4-preview"]
+"package-lva-1-0-4-preview" = []
diff --git a/services/svc/mediaservices/src/lib.rs b/services/svc/mediaservices/src/lib.rs
new file mode 100644
index 0000000000..8c7b5d1df4
--- /dev/null
+++ b/services/svc/mediaservices/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-lva-1-0-4-preview")]
+mod package_lva_1_0_4_preview;
+use azure_core::setters;
+#[cfg(feature = "package-lva-1-0-4-preview")]
+pub use package_lva_1_0_4_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/mediaservices/src/package_lva_1_0_4_preview/mod.rs b/services/svc/mediaservices/src/package_lva_1_0_4_preview/mod.rs
new file mode 100644
index 0000000000..dfbe692eee
--- /dev/null
+++ b/services/svc/mediaservices/src/package_lva_1_0_4_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2.0.0";
diff --git a/services/svc/mediaservices/src/package_lva_1_0_4_preview/models.rs b/services/svc/mediaservices/src/package_lva_1_0_4_preview/models.rs
new file mode 100644
index 0000000000..388bdb800a
--- /dev/null
+++ b/services/svc/mediaservices/src/package_lva_1_0_4_preview/models.rs
@@ -0,0 +1,507 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstance {
+    pub name: String,
+    #[serde(rename = "systemData", default, skip_serializing_if = "Option::is_none")]
+    pub system_data: Option<MediaGraphSystemData>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<MediaGraphInstanceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "topologyName", default, skip_serializing_if = "Option::is_none")]
+    pub topology_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<MediaGraphParameterDefinition>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<media_graph_instance_properties::State>,
+}
+pub mod media_graph_instance_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        Inactive,
+        Activating,
+        Active,
+        Deactivating,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphParameterDefinition {
+    pub name: String,
+    pub value: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceCollection {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<MediaGraphInstance>,
+    #[serde(rename = "@continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTopologyCollection {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<MediaGraphTopology>,
+    #[serde(rename = "@continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTopology {
+    pub name: String,
+    #[serde(rename = "systemData", default, skip_serializing_if = "Option::is_none")]
+    pub system_data: Option<MediaGraphSystemData>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<MediaGraphTopologyProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTopologyProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<MediaGraphParameterDeclaration>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sources: Vec<MediaGraphSource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub processors: Vec<MediaGraphProcessor>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sinks: Vec<MediaGraphSink>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphSystemData {
+    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
+    pub created_at: Option<String>,
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphParameterDeclaration {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: media_graph_parameter_declaration::Type,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub default: Option<String>,
+}
+pub mod media_graph_parameter_declaration {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        String,
+        SecretString,
+        Int,
+        Double,
+        Bool,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphSource {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    pub name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphRtspSource {
+    #[serde(flatten)]
+    pub media_graph_source: MediaGraphSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub transport: Option<media_graph_rtsp_source::Transport>,
+    pub endpoint: MediaGraphEndpoint,
+}
+pub mod media_graph_rtsp_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Transport {
+        Http,
+        Tcp,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphIoTHubMessageSource {
+    #[serde(flatten)]
+    pub media_graph_source: MediaGraphSource,
+    #[serde(rename = "hubInputName", default, skip_serializing_if = "Option::is_none")]
+    pub hub_input_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphIoTHubMessageSink {
+    #[serde(flatten)]
+    pub media_graph_sink: MediaGraphSink,
+    #[serde(rename = "hubOutputName")]
+    pub hub_output_name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphEndpoint {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credentials: Option<MediaGraphCredentials>,
+    pub url: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphCredentials {
+    #[serde(rename = "@type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphUsernamePasswordCredentials {
+    #[serde(flatten)]
+    pub media_graph_credentials: MediaGraphCredentials,
+    pub username: String,
+    pub password: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphHttpHeaderCredentials {
+    #[serde(flatten)]
+    pub media_graph_credentials: MediaGraphCredentials,
+    #[serde(rename = "headerName")]
+    pub header_name: String,
+    #[serde(rename = "headerValue")]
+    pub header_value: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphUnsecuredEndpoint {
+    #[serde(flatten)]
+    pub media_graph_endpoint: MediaGraphEndpoint,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTlsEndpoint {
+    #[serde(flatten)]
+    pub media_graph_endpoint: MediaGraphEndpoint,
+    #[serde(rename = "trustedCertificates", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_certificates: Option<MediaGraphCertificateSource>,
+    #[serde(rename = "validationOptions", default, skip_serializing_if = "Option::is_none")]
+    pub validation_options: Option<MediaGraphTlsValidationOptions>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphCertificateSource {
+    #[serde(rename = "@type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTlsValidationOptions {
+    #[serde(rename = "ignoreHostname", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_hostname: Option<String>,
+    #[serde(rename = "ignoreSignature", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_signature: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphPemCertificateList {
+    #[serde(flatten)]
+    pub media_graph_certificate_source: MediaGraphCertificateSource,
+    pub certificates: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphSink {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    pub name: String,
+    pub inputs: Vec<MediaGraphNodeInput>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphNodeInput {
+    #[serde(rename = "nodeName")]
+    pub node_name: String,
+    #[serde(rename = "outputSelectors", default, skip_serializing_if = "Vec::is_empty")]
+    pub output_selectors: Vec<MediaGraphOutputSelector>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphOutputSelector {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub property: Option<media_graph_output_selector::Property>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub operator: Option<media_graph_output_selector::Operator>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+pub mod media_graph_output_selector {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Property {
+        #[serde(rename = "mediaType")]
+        MediaType,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operator {
+        #[serde(rename = "is")]
+        Is,
+        #[serde(rename = "isNot")]
+        IsNot,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphFileSink {
+    #[serde(flatten)]
+    pub media_graph_sink: MediaGraphSink,
+    #[serde(rename = "baseDirectoryPath")]
+    pub base_directory_path: String,
+    #[serde(rename = "fileNamePattern")]
+    pub file_name_pattern: String,
+    #[serde(rename = "maximumSizeMiB")]
+    pub maximum_size_mi_b: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphAssetSink {
+    #[serde(flatten)]
+    pub media_graph_sink: MediaGraphSink,
+    #[serde(rename = "assetNamePattern")]
+    pub asset_name_pattern: String,
+    #[serde(rename = "segmentLength", default, skip_serializing_if = "Option::is_none")]
+    pub segment_length: Option<String>,
+    #[serde(rename = "localMediaCachePath")]
+    pub local_media_cache_path: String,
+    #[serde(rename = "localMediaCacheMaximumSizeMiB")]
+    pub local_media_cache_maximum_size_mi_b: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphProcessor {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    pub name: String,
+    pub inputs: Vec<MediaGraphNodeInput>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphMotionDetectionProcessor {
+    #[serde(flatten)]
+    pub media_graph_processor: MediaGraphProcessor,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sensitivity: Option<media_graph_motion_detection_processor::Sensitivity>,
+    #[serde(rename = "outputMotionRegion", default, skip_serializing_if = "Option::is_none")]
+    pub output_motion_region: Option<bool>,
+    #[serde(rename = "eventAggregationWindow", default, skip_serializing_if = "Option::is_none")]
+    pub event_aggregation_window: Option<String>,
+}
+pub mod media_graph_motion_detection_processor {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Sensitivity {
+        Low,
+        Medium,
+        High,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphExtensionProcessorBase {
+    #[serde(flatten)]
+    pub media_graph_processor: MediaGraphProcessor,
+    pub endpoint: MediaGraphEndpoint,
+    pub image: MediaGraphImage,
+    #[serde(rename = "samplingOptions", default, skip_serializing_if = "Option::is_none")]
+    pub sampling_options: Option<MediaGraphSamplingOptions>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphCognitiveServicesVisionExtension {
+    #[serde(flatten)]
+    pub media_graph_extension_processor_base: MediaGraphExtensionProcessorBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphGrpcExtension {
+    #[serde(flatten)]
+    pub media_graph_extension_processor_base: MediaGraphExtensionProcessorBase,
+    #[serde(rename = "dataTransfer")]
+    pub data_transfer: MediaGraphGrpcExtensionDataTransfer,
+    #[serde(rename = "extensionConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub extension_configuration: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphGrpcExtensionDataTransfer {
+    #[serde(rename = "sharedMemorySizeMiB", default, skip_serializing_if = "Option::is_none")]
+    pub shared_memory_size_mi_b: Option<String>,
+    pub mode: media_graph_grpc_extension_data_transfer::Mode,
+}
+pub mod media_graph_grpc_extension_data_transfer {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Mode {
+        Embedded,
+        SharedMemory,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphHttpExtension {
+    #[serde(flatten)]
+    pub media_graph_extension_processor_base: MediaGraphExtensionProcessorBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphImage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scale: Option<MediaGraphImageScale>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<MediaGraphImageFormat>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphSamplingOptions {
+    #[serde(rename = "skipSamplesWithoutAnnotation", default, skip_serializing_if = "Option::is_none")]
+    pub skip_samples_without_annotation: Option<String>,
+    #[serde(rename = "maximumSamplesPerSecond", default, skip_serializing_if = "Option::is_none")]
+    pub maximum_samples_per_second: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphImageScale {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mode: Option<media_graph_image_scale::Mode>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub width: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub height: Option<String>,
+}
+pub mod media_graph_image_scale {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Mode {
+        PreserveAspectRatio,
+        Pad,
+        Stretch,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphImageFormat {
+    #[serde(rename = "@type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphImageFormatRaw {
+    #[serde(flatten)]
+    pub media_graph_image_format: MediaGraphImageFormat,
+    #[serde(rename = "pixelFormat")]
+    pub pixel_format: media_graph_image_format_raw::PixelFormat,
+}
+pub mod media_graph_image_format_raw {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PixelFormat {
+        Yuv420p,
+        Rgb565be,
+        Rgb565le,
+        Rgb555be,
+        Rgb555le,
+        Rgb24,
+        Bgr24,
+        Argb,
+        Rgba,
+        Abgr,
+        Bgra,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphImageFormatJpeg {
+    #[serde(flatten)]
+    pub media_graph_image_format: MediaGraphImageFormat,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub quality: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphImageFormatBmp {
+    #[serde(flatten)]
+    pub media_graph_image_format: MediaGraphImageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphImageFormatPng {
+    #[serde(flatten)]
+    pub media_graph_image_format: MediaGraphImageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphSignalGateProcessor {
+    #[serde(flatten)]
+    pub media_graph_processor: MediaGraphProcessor,
+    #[serde(rename = "activationEvaluationWindow", default, skip_serializing_if = "Option::is_none")]
+    pub activation_evaluation_window: Option<String>,
+    #[serde(rename = "activationSignalOffset", default, skip_serializing_if = "Option::is_none")]
+    pub activation_signal_offset: Option<String>,
+    #[serde(rename = "minimumActivationTime", default, skip_serializing_if = "Option::is_none")]
+    pub minimum_activation_time: Option<String>,
+    #[serde(rename = "maximumActivationTime", default, skip_serializing_if = "Option::is_none")]
+    pub maximum_activation_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MethodRequest {
+    #[serde(rename = "methodName")]
+    pub method_name: String,
+    #[serde(rename = "@apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<method_request::ApiVersion>,
+}
+pub mod method_request {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ApiVersion {
+        #[serde(rename = "2.0")]
+        _2_0,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTopologySetRequest {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    pub graph: MediaGraphTopology,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTopologySetRequestBody {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    #[serde(flatten)]
+    pub media_graph_topology: MediaGraphTopology,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceSetRequest {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    pub instance: MediaGraphInstance,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceSetRequestBody {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    #[serde(flatten)]
+    pub media_graph_instance: MediaGraphInstance,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ItemNonSetRequestBase {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    pub name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTopologyListRequest {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTopologyGetRequest {
+    #[serde(flatten)]
+    pub item_non_set_request_base: ItemNonSetRequestBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphTopologyDeleteRequest {
+    #[serde(flatten)]
+    pub item_non_set_request_base: ItemNonSetRequestBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceListRequest {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceGetRequest {
+    #[serde(flatten)]
+    pub item_non_set_request_base: ItemNonSetRequestBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceActivateRequest {
+    #[serde(flatten)]
+    pub item_non_set_request_base: ItemNonSetRequestBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceDeActivateRequest {
+    #[serde(flatten)]
+    pub item_non_set_request_base: ItemNonSetRequestBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MediaGraphInstanceDeleteRequest {
+    #[serde(flatten)]
+    pub item_non_set_request_base: ItemNonSetRequestBase,
+}
diff --git a/services/svc/mediaservices/src/package_lva_1_0_4_preview/operations.rs b/services/svc/mediaservices/src/package_lva_1_0_4_preview/operations.rs
new file mode 100644
index 0000000000..82a7a1cf58
--- /dev/null
+++ b/services/svc/mediaservices/src/package_lva_1_0_4_preview/operations.rs
@@ -0,0 +1,5 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
diff --git a/services/svc/mixedreality/Cargo.toml b/services/svc/mixedreality/Cargo.toml
new file mode 100644
index 0000000000..67a926b516
--- /dev/null
+++ b/services/svc/mixedreality/Cargo.toml
@@ -0,0 +1,27 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_mixedreality"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2021-01-01"]
+"package-0.2-preview.1" = []
+"package-2021-01-01" = []
+"package-0.2-preview.0" = []
+"package-2021-01-01-preview" = []
+"package-2019-02-28-preview" = []
diff --git a/services/svc/mixedreality/src/lib.rs b/services/svc/mixedreality/src/lib.rs
new file mode 100644
index 0000000000..054ed4f7c0
--- /dev/null
+++ b/services/svc/mixedreality/src/lib.rs
@@ -0,0 +1,77 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-0.2-preview.1")]
+mod package_0_2_preview_1;
+#[cfg(feature = "package-0.2-preview.1")]
+pub use package_0_2_preview_1::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-01-01")]
+mod package_2021_01_01;
+#[cfg(feature = "package-2021-01-01")]
+pub use package_2021_01_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-0.2-preview.0")]
+mod package_0_2_preview_0;
+#[cfg(feature = "package-0.2-preview.0")]
+pub use package_0_2_preview_0::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-01-01-preview")]
+mod package_2021_01_01_preview;
+#[cfg(feature = "package-2021-01-01-preview")]
+pub use package_2021_01_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-2019-02-28-preview")]
+mod package_2019_02_28_preview;
+use azure_core::setters;
+#[cfg(feature = "package-2019-02-28-preview")]
+pub use package_2019_02_28_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/mixedreality/src/package_0_2_preview_0/mod.rs b/services/svc/mixedreality/src/package_0_2_preview_0/mod.rs
new file mode 100644
index 0000000000..950877fcf1
--- /dev/null
+++ b/services/svc/mixedreality/src/package_0_2_preview_0/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "0.2-preview.0";
diff --git a/services/svc/mixedreality/src/package_0_2_preview_0/models.rs b/services/svc/mixedreality/src/package_0_2_preview_0/models.rs
new file mode 100644
index 0000000000..d5d8253002
--- /dev/null
+++ b/services/svc/mixedreality/src/package_0_2_preview_0/models.rs
@@ -0,0 +1,96 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JobStatus {
+    NotStarted,
+    Running,
+    Succeeded,
+    Failed,
+    Cancelled,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Vector3 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Quaternion {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub w: f32,
+    #[serde(rename = "isIdentity", default, skip_serializing_if = "Option::is_none")]
+    pub is_identity: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Pose {
+    pub rotation: Quaternion,
+    pub translation: Vector3,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Vector4 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub w: f32,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IngestionConfiguration {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dimensions: Option<Vector3>,
+    #[serde(rename = "boundingBoxCenter", default, skip_serializing_if = "Option::is_none")]
+    pub bounding_box_center: Option<Vector3>,
+    pub gravity: Vector3,
+    #[serde(rename = "keyFrameIndexes", default, skip_serializing_if = "Vec::is_empty")]
+    pub key_frame_indexes: Vec<i32>,
+    #[serde(rename = "gtTrajectory", default, skip_serializing_if = "Vec::is_empty")]
+    pub gt_trajectory: Vec<Pose>,
+    #[serde(rename = "principalAxis", default, skip_serializing_if = "Option::is_none")]
+    pub principal_axis: Option<Quaternion>,
+    pub scale: f32,
+    #[serde(rename = "supportingPlane", default, skip_serializing_if = "Option::is_none")]
+    pub supporting_plane: Option<Vector4>,
+    #[serde(rename = "testTrajectory", default, skip_serializing_if = "Vec::is_empty")]
+    pub test_trajectory: Vec<Pose>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IngestionProperties {
+    #[serde(rename = "clientErrorDetails", default, skip_serializing_if = "Option::is_none")]
+    pub client_error_details: Option<String>,
+    #[serde(rename = "serverErrorDetails", default, skip_serializing_if = "Option::is_none")]
+    pub server_error_details: Option<String>,
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    #[serde(rename = "outputModelUri", default, skip_serializing_if = "Option::is_none")]
+    pub output_model_uri: Option<String>,
+    #[serde(rename = "jobStatus", default, skip_serializing_if = "Option::is_none")]
+    pub job_status: Option<JobStatus>,
+    #[serde(rename = "assetFileType", default, skip_serializing_if = "Option::is_none")]
+    pub asset_file_type: Option<String>,
+    #[serde(rename = "inputAssetUri", default, skip_serializing_if = "Option::is_none")]
+    pub input_asset_uri: Option<String>,
+    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
+    pub account_id: Option<String>,
+    #[serde(rename = "ingestionConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_configuration: Option<IngestionConfiguration>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Error {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<Error>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UploadLocation {
+    #[serde(rename = "inputAssetUri")]
+    pub input_asset_uri: String,
+}
diff --git a/services/svc/mixedreality/src/package_0_2_preview_0/operations.rs b/services/svc/mixedreality/src/package_0_2_preview_0/operations.rs
new file mode 100644
index 0000000000..36c319b141
--- /dev/null
+++ b/services/svc/mixedreality/src/package_0_2_preview_0/operations.rs
@@ -0,0 +1,216 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod ingestion_job {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        job_id: &str,
+        x_mrc_cv: Option<&str>,
+    ) -> std::result::Result<IngestionProperties, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/jobs/{}", operation_config.base_path(), account_id, job_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_mrc_cv) = x_mrc_cv {
+            req_builder = req_builder.header("x-mrc-cv", x_mrc_cv);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IngestionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        job_id: &str,
+        x_mrc_cv: Option<&str>,
+        body: Option<&IngestionProperties>,
+    ) -> std::result::Result<IngestionProperties, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/jobs/{}", operation_config.base_path(), account_id, job_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_mrc_cv) = x_mrc_cv {
+            req_builder = req_builder.header("x-mrc-cv", x_mrc_cv);
+        }
+        let req_body = if let Some(body) = body {
+            azure_core::to_json(body).map_err(create::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: IngestionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod blob_upload_endpoint {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        x_mrc_cv: Option<&str>,
+    ) -> std::result::Result<UploadLocation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/blobUploadEndpoint", operation_config.base_path(), account_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_mrc_cv) = x_mrc_cv {
+            req_builder = req_builder.header("x-mrc-cv", x_mrc_cv);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: UploadLocation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/mixedreality/src/package_0_2_preview_1/mod.rs b/services/svc/mixedreality/src/package_0_2_preview_1/mod.rs
new file mode 100644
index 0000000000..b4defb8f96
--- /dev/null
+++ b/services/svc/mixedreality/src/package_0_2_preview_1/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "0.2-preview.1";
diff --git a/services/svc/mixedreality/src/package_0_2_preview_1/models.rs b/services/svc/mixedreality/src/package_0_2_preview_1/models.rs
new file mode 100644
index 0000000000..f7ae4210cd
--- /dev/null
+++ b/services/svc/mixedreality/src/package_0_2_preview_1/models.rs
@@ -0,0 +1,129 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ConversionErrorCode {
+    #[serde(rename = "UNKNOWN")]
+    Unknown,
+    #[serde(rename = "NO_ERROR")]
+    NoError,
+    #[serde(rename = "SERVICE_ERROR")]
+    ServiceError,
+    #[serde(rename = "INVALID_ASSET_URI")]
+    InvalidAssetUri,
+    #[serde(rename = "INVALID_JOB_ID")]
+    InvalidJobId,
+    #[serde(rename = "INVALID_GRAVITY")]
+    InvalidGravity,
+    #[serde(rename = "INVALID_SCALE")]
+    InvalidScale,
+    #[serde(rename = "ASSET_SIZE_TOO_LARGE")]
+    AssetSizeTooLarge,
+    #[serde(rename = "ASSET_DIMENSIONS_OUT_OF_BOUNDS")]
+    AssetDimensionsOutOfBounds,
+    #[serde(rename = "ZERO_FACES")]
+    ZeroFaces,
+    #[serde(rename = "INVALID_FACE_VERTICES")]
+    InvalidFaceVertices,
+    #[serde(rename = "ZERO_TRAJECTORIES_GENERATED")]
+    ZeroTrajectoriesGenerated,
+    #[serde(rename = "TOO_MANY_RIG_POSES")]
+    TooManyRigPoses,
+    #[serde(rename = "ASSET_CANNOT_BE_CONVERTED")]
+    AssetCannotBeConverted,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JobStatus {
+    NotStarted,
+    Running,
+    Succeeded,
+    Failed,
+    Cancelled,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Vector3 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Quaternion {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub w: f32,
+    #[serde(rename = "isIdentity", default, skip_serializing_if = "Option::is_none")]
+    pub is_identity: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Pose {
+    pub rotation: Quaternion,
+    pub translation: Vector3,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Vector4 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub w: f32,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IngestionConfiguration {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dimensions: Option<Vector3>,
+    #[serde(rename = "boundingBoxCenter", default, skip_serializing_if = "Option::is_none")]
+    pub bounding_box_center: Option<Vector3>,
+    pub gravity: Vector3,
+    #[serde(rename = "keyFrameIndexes", default, skip_serializing_if = "Vec::is_empty")]
+    pub key_frame_indexes: Vec<i32>,
+    #[serde(rename = "gtTrajectory", default, skip_serializing_if = "Vec::is_empty")]
+    pub gt_trajectory: Vec<Pose>,
+    #[serde(rename = "principalAxis", default, skip_serializing_if = "Option::is_none")]
+    pub principal_axis: Option<Quaternion>,
+    pub scale: f32,
+    #[serde(rename = "supportingPlane", default, skip_serializing_if = "Option::is_none")]
+    pub supporting_plane: Option<Vector4>,
+    #[serde(rename = "testTrajectory", default, skip_serializing_if = "Vec::is_empty")]
+    pub test_trajectory: Vec<Pose>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IngestionProperties {
+    #[serde(rename = "clientErrorDetails", default, skip_serializing_if = "Option::is_none")]
+    pub client_error_details: Option<String>,
+    #[serde(rename = "serverErrorDetails", default, skip_serializing_if = "Option::is_none")]
+    pub server_error_details: Option<String>,
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<ConversionErrorCode>,
+    #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
+    pub job_id: Option<String>,
+    #[serde(rename = "outputModelUri", default, skip_serializing_if = "Option::is_none")]
+    pub output_model_uri: Option<String>,
+    #[serde(rename = "jobStatus", default, skip_serializing_if = "Option::is_none")]
+    pub job_status: Option<JobStatus>,
+    #[serde(rename = "assetFileType", default, skip_serializing_if = "Option::is_none")]
+    pub asset_file_type: Option<String>,
+    #[serde(rename = "inputAssetUri", default, skip_serializing_if = "Option::is_none")]
+    pub input_asset_uri: Option<String>,
+    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
+    pub account_id: Option<String>,
+    #[serde(rename = "ingestionConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_configuration: Option<IngestionConfiguration>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Error {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<Error>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UploadLocation {
+    #[serde(rename = "inputAssetUri")]
+    pub input_asset_uri: String,
+}
diff --git a/services/svc/mixedreality/src/package_0_2_preview_1/operations.rs b/services/svc/mixedreality/src/package_0_2_preview_1/operations.rs
new file mode 100644
index 0000000000..36c319b141
--- /dev/null
+++ b/services/svc/mixedreality/src/package_0_2_preview_1/operations.rs
@@ -0,0 +1,216 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod ingestion_job {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        job_id: &str,
+        x_mrc_cv: Option<&str>,
+    ) -> std::result::Result<IngestionProperties, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/jobs/{}", operation_config.base_path(), account_id, job_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_mrc_cv) = x_mrc_cv {
+            req_builder = req_builder.header("x-mrc-cv", x_mrc_cv);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IngestionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        job_id: &str,
+        x_mrc_cv: Option<&str>,
+        body: Option<&IngestionProperties>,
+    ) -> std::result::Result<IngestionProperties, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/jobs/{}", operation_config.base_path(), account_id, job_id);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_mrc_cv) = x_mrc_cv {
+            req_builder = req_builder.header("x-mrc-cv", x_mrc_cv);
+        }
+        let req_body = if let Some(body) = body {
+            azure_core::to_json(body).map_err(create::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: IngestionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod blob_upload_endpoint {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        x_mrc_cv: Option<&str>,
+    ) -> std::result::Result<UploadLocation, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/blobUploadEndpoint", operation_config.base_path(), account_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_mrc_cv) = x_mrc_cv {
+            req_builder = req_builder.header("x-mrc-cv", x_mrc_cv);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: UploadLocation =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/mixedreality/src/package_2019_02_28_preview/mod.rs b/services/svc/mixedreality/src/package_2019_02_28_preview/mod.rs
new file mode 100644
index 0000000000..04f8255807
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2019_02_28_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-02-28-preview";
diff --git a/services/svc/mixedreality/src/package_2019_02_28_preview/models.rs b/services/svc/mixedreality/src/package_2019_02_28_preview/models.rs
new file mode 100644
index 0000000000..8a9cd5266a
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2019_02_28_preview/models.rs
@@ -0,0 +1,9 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StsTokenResponseMessage {
+    #[serde(rename = "AccessToken")]
+    pub access_token: String,
+}
diff --git a/services/svc/mixedreality/src/package_2019_02_28_preview/operations.rs b/services/svc/mixedreality/src/package_2019_02_28_preview/operations.rs
new file mode 100644
index 0000000000..3f0ca672f8
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2019_02_28_preview/operations.rs
@@ -0,0 +1,72 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub async fn get_token(
+    operation_config: &crate::OperationConfig,
+    account_id: &str,
+    x_mrc_cv: Option<&str>,
+) -> std::result::Result<StsTokenResponseMessage, get_token::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/Accounts/{}/token", operation_config.base_path(), account_id);
+    let mut url = url::Url::parse(url_str).map_err(get_token::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_token::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(x_mrc_cv) = x_mrc_cv {
+        req_builder = req_builder.header("X-MRC-CV", x_mrc_cv);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_token::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_token::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: StsTokenResponseMessage =
+                serde_json::from_slice(rsp_body).map_err(|source| get_token::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        http::StatusCode::BAD_REQUEST => Err(get_token::Error::BadRequest400 {}),
+        http::StatusCode::UNAUTHORIZED => Err(get_token::Error::Unauthorized401 {}),
+        http::StatusCode::TOO_MANY_REQUESTS => Err(get_token::Error::TooManyRequests429 {}),
+        status_code => Err(get_token::Error::DefaultResponse { status_code }),
+    }
+}
+pub mod get_token {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("Error response #response_type")]
+        BadRequest400 {},
+        #[error("Error response #response_type")]
+        Unauthorized401 {},
+        #[error("Error response #response_type")]
+        TooManyRequests429 {},
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse { status_code: http::StatusCode },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
diff --git a/services/svc/mixedreality/src/package_2021_01_01/mod.rs b/services/svc/mixedreality/src/package_2021_01_01/mod.rs
new file mode 100644
index 0000000000..1a193f3aea
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2021_01_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-01-01";
diff --git a/services/svc/mixedreality/src/package_2021_01_01/models.rs b/services/svc/mixedreality/src/package_2021_01_01/models.rs
new file mode 100644
index 0000000000..01d67a5643
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2021_01_01/models.rs
@@ -0,0 +1,137 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Conversion {
+    pub id: String,
+    pub settings: ConversionSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<conversion::Output>,
+    pub error: Error,
+    pub status: ConversionStatus,
+    #[serde(rename = "creationTime")]
+    pub creation_time: String,
+}
+pub mod conversion {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Output {
+        #[serde(rename = "outputAssetUri", default, skip_serializing_if = "Option::is_none")]
+        pub output_asset_uri: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConversionList {
+    pub conversions: Vec<Conversion>,
+    #[serde(rename = "@nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConversionInputSettings {
+    #[serde(rename = "storageContainerUri")]
+    pub storage_container_uri: String,
+    #[serde(rename = "storageContainerReadListSas", default, skip_serializing_if = "Option::is_none")]
+    pub storage_container_read_list_sas: Option<String>,
+    #[serde(rename = "blobPrefix", default, skip_serializing_if = "Option::is_none")]
+    pub blob_prefix: Option<String>,
+    #[serde(rename = "relativeInputAssetPath")]
+    pub relative_input_asset_path: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConversionOutputSettings {
+    #[serde(rename = "storageContainerUri")]
+    pub storage_container_uri: String,
+    #[serde(rename = "storageContainerWriteSas", default, skip_serializing_if = "Option::is_none")]
+    pub storage_container_write_sas: Option<String>,
+    #[serde(rename = "blobPrefix", default, skip_serializing_if = "Option::is_none")]
+    pub blob_prefix: Option<String>,
+    #[serde(rename = "outputAssetFilename", default, skip_serializing_if = "Option::is_none")]
+    pub output_asset_filename: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateConversionSettings {
+    pub settings: ConversionSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConversionSettings {
+    #[serde(rename = "inputLocation")]
+    pub input_location: ConversionInputSettings,
+    #[serde(rename = "outputLocation")]
+    pub output_location: ConversionOutputSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ConversionStatus {
+    NotStarted,
+    Running,
+    Cancelled,
+    Failed,
+    Succeeded,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    pub error: Error,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Error {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(rename = "innerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Box<Option<Error>>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SessionProperties {
+    pub id: String,
+    #[serde(rename = "arrInspectorPort", default, skip_serializing_if = "Option::is_none")]
+    pub arr_inspector_port: Option<i64>,
+    #[serde(rename = "handshakePort", default, skip_serializing_if = "Option::is_none")]
+    pub handshake_port: Option<i64>,
+    #[serde(rename = "elapsedTimeMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub elapsed_time_minutes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub hostname: Option<String>,
+    #[serde(rename = "maxLeaseTimeMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub max_lease_time_minutes: Option<i64>,
+    pub size: SessionSize,
+    pub status: SessionStatus,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub teraflops: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<Error>,
+    #[serde(rename = "creationTime", default, skip_serializing_if = "Option::is_none")]
+    pub creation_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateSessionSettings {
+    #[serde(rename = "maxLeaseTimeMinutes")]
+    pub max_lease_time_minutes: i64,
+    pub size: SessionSize,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UpdateSessionSettings {
+    #[serde(rename = "maxLeaseTimeMinutes")]
+    pub max_lease_time_minutes: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SessionStatus {
+    Error,
+    Expired,
+    Starting,
+    Ready,
+    Stopped,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SessionSize {
+    Standard,
+    Premium,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SessionsList {
+    pub sessions: Vec<SessionProperties>,
+    #[serde(rename = "@nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
diff --git a/services/svc/mixedreality/src/package_2021_01_01/operations.rs b/services/svc/mixedreality/src/package_2021_01_01/operations.rs
new file mode 100644
index 0000000000..471ef22a97
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2021_01_01/operations.rs
@@ -0,0 +1,718 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod remote_rendering {
+    use crate::models::*;
+    pub async fn get_conversion(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        conversion_id: &str,
+    ) -> std::result::Result<Conversion, get_conversion::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/accounts/{}/conversions/{}",
+            operation_config.base_path(),
+            account_id,
+            conversion_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_conversion::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_conversion::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_conversion::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_conversion::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Conversion =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(get_conversion::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(get_conversion::Error::Forbidden403 {}),
+            http::StatusCode::NOT_FOUND => Err(get_conversion::Error::NotFound404 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(get_conversion::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_conversion::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_conversion::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_conversion {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_conversion(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        conversion_id: &str,
+        body: &CreateConversionSettings,
+    ) -> std::result::Result<create_conversion::Response, create_conversion::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/accounts/{}/conversions/{}",
+            operation_config.base_path(),
+            account_id,
+            conversion_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_conversion::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_conversion::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_conversion::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_conversion::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_conversion::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Conversion = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_conversion::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: Conversion = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_conversion::Response::Created201(rsp_value))
+            }
+            http::StatusCode::BAD_REQUEST => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_conversion::Error::BadRequest400 { value: rsp_value })
+            }
+            http::StatusCode::UNAUTHORIZED => Err(create_conversion::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(create_conversion::Error::Forbidden403 {}),
+            http::StatusCode::CONFLICT => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_conversion::Error::Conflict409 { value: rsp_value })
+            }
+            http::StatusCode::TOO_MANY_REQUESTS => Err(create_conversion::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_conversion::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_conversion::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_conversion {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(Conversion),
+            Created201(Conversion),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            BadRequest400 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            Conflict409 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_conversions(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+    ) -> std::result::Result<ConversionList, list_conversions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/conversions", operation_config.base_path(), account_id);
+        let mut url = url::Url::parse(url_str).map_err(list_conversions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_conversions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_conversions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_conversions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConversionList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_conversions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(list_conversions::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(list_conversions::Error::Forbidden403 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(list_conversions::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_conversions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_conversions::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_conversions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_conversions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_session(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        session_id: &str,
+    ) -> std::result::Result<SessionProperties, get_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/sessions/{}", operation_config.base_path(), account_id, session_id);
+        let mut url = url::Url::parse(url_str).map_err(get_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(get_session::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(get_session::Error::Forbidden403 {}),
+            http::StatusCode::NOT_FOUND => Err(get_session::Error::NotFound404 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(get_session::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_session::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_session(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        session_id: &str,
+        body: &CreateSessionSettings,
+    ) -> std::result::Result<create_session::Response, create_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/sessions/{}", operation_config.base_path(), account_id, session_id);
+        let mut url = url::Url::parse(url_str).map_err(create_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_session::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_session::Response::Created201(rsp_value))
+            }
+            http::StatusCode::BAD_REQUEST => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_session::Error::BadRequest400 { value: rsp_value })
+            }
+            http::StatusCode::UNAUTHORIZED => Err(create_session::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(create_session::Error::Forbidden403 {}),
+            http::StatusCode::CONFLICT => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_session::Error::Conflict409 { value: rsp_value })
+            }
+            http::StatusCode::TOO_MANY_REQUESTS => Err(create_session::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_session::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_session {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SessionProperties),
+            Created201(SessionProperties),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            BadRequest400 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            Conflict409 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_session(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        session_id: &str,
+        body: &UpdateSessionSettings,
+    ) -> std::result::Result<SessionProperties, update_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/sessions/{}", operation_config.base_path(), account_id, session_id);
+        let mut url = url::Url::parse(url_str).map_err(update_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| update_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(update_session::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(update_session::Error::Forbidden403 {}),
+            http::StatusCode::NOT_FOUND => Err(update_session::Error::NotFound404 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(update_session::Error::TooManyRequests429 {}),
+            http::StatusCode::UNPROCESSABLE_ENTITY => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| update_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_session::Error::UnprocessableEntity422 { value: rsp_value })
+            }
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| update_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_session::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            UnprocessableEntity422 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn stop_session(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        session_id: &str,
+    ) -> std::result::Result<(), stop_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/accounts/{}/sessions/{}/:stop",
+            operation_config.base_path(),
+            account_id,
+            session_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(stop_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(stop_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(stop_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(stop_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            http::StatusCode::UNAUTHORIZED => Err(stop_session::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(stop_session::Error::Forbidden403 {}),
+            http::StatusCode::NOT_FOUND => Err(stop_session::Error::NotFound404 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(stop_session::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| stop_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(stop_session::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(stop_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod stop_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_sessions(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+    ) -> std::result::Result<SessionsList, list_sessions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/sessions", operation_config.base_path(), account_id);
+        let mut url = url::Url::parse(url_str).map_err(list_sessions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_sessions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_sessions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_sessions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionsList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_sessions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(list_sessions::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(list_sessions::Error::Forbidden403 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(list_sessions::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_sessions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_sessions::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_sessions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_sessions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/mixedreality/src/package_2021_01_01_preview/mod.rs b/services/svc/mixedreality/src/package_2021_01_01_preview/mod.rs
new file mode 100644
index 0000000000..c0fdf4a32f
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2021_01_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-01-01-preview";
diff --git a/services/svc/mixedreality/src/package_2021_01_01_preview/models.rs b/services/svc/mixedreality/src/package_2021_01_01_preview/models.rs
new file mode 100644
index 0000000000..01d67a5643
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2021_01_01_preview/models.rs
@@ -0,0 +1,137 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Conversion {
+    pub id: String,
+    pub settings: ConversionSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<conversion::Output>,
+    pub error: Error,
+    pub status: ConversionStatus,
+    #[serde(rename = "creationTime")]
+    pub creation_time: String,
+}
+pub mod conversion {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Output {
+        #[serde(rename = "outputAssetUri", default, skip_serializing_if = "Option::is_none")]
+        pub output_asset_uri: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConversionList {
+    pub conversions: Vec<Conversion>,
+    #[serde(rename = "@nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConversionInputSettings {
+    #[serde(rename = "storageContainerUri")]
+    pub storage_container_uri: String,
+    #[serde(rename = "storageContainerReadListSas", default, skip_serializing_if = "Option::is_none")]
+    pub storage_container_read_list_sas: Option<String>,
+    #[serde(rename = "blobPrefix", default, skip_serializing_if = "Option::is_none")]
+    pub blob_prefix: Option<String>,
+    #[serde(rename = "relativeInputAssetPath")]
+    pub relative_input_asset_path: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConversionOutputSettings {
+    #[serde(rename = "storageContainerUri")]
+    pub storage_container_uri: String,
+    #[serde(rename = "storageContainerWriteSas", default, skip_serializing_if = "Option::is_none")]
+    pub storage_container_write_sas: Option<String>,
+    #[serde(rename = "blobPrefix", default, skip_serializing_if = "Option::is_none")]
+    pub blob_prefix: Option<String>,
+    #[serde(rename = "outputAssetFilename", default, skip_serializing_if = "Option::is_none")]
+    pub output_asset_filename: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateConversionSettings {
+    pub settings: ConversionSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConversionSettings {
+    #[serde(rename = "inputLocation")]
+    pub input_location: ConversionInputSettings,
+    #[serde(rename = "outputLocation")]
+    pub output_location: ConversionOutputSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ConversionStatus {
+    NotStarted,
+    Running,
+    Cancelled,
+    Failed,
+    Succeeded,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    pub error: Error,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Error {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<Error>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(rename = "innerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Box<Option<Error>>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SessionProperties {
+    pub id: String,
+    #[serde(rename = "arrInspectorPort", default, skip_serializing_if = "Option::is_none")]
+    pub arr_inspector_port: Option<i64>,
+    #[serde(rename = "handshakePort", default, skip_serializing_if = "Option::is_none")]
+    pub handshake_port: Option<i64>,
+    #[serde(rename = "elapsedTimeMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub elapsed_time_minutes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub hostname: Option<String>,
+    #[serde(rename = "maxLeaseTimeMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub max_lease_time_minutes: Option<i64>,
+    pub size: SessionSize,
+    pub status: SessionStatus,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub teraflops: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<Error>,
+    #[serde(rename = "creationTime", default, skip_serializing_if = "Option::is_none")]
+    pub creation_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateSessionSettings {
+    #[serde(rename = "maxLeaseTimeMinutes")]
+    pub max_lease_time_minutes: i64,
+    pub size: SessionSize,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UpdateSessionSettings {
+    #[serde(rename = "maxLeaseTimeMinutes")]
+    pub max_lease_time_minutes: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SessionStatus {
+    Error,
+    Expired,
+    Starting,
+    Ready,
+    Stopped,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SessionSize {
+    Standard,
+    Premium,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SessionsList {
+    pub sessions: Vec<SessionProperties>,
+    #[serde(rename = "@nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
diff --git a/services/svc/mixedreality/src/package_2021_01_01_preview/operations.rs b/services/svc/mixedreality/src/package_2021_01_01_preview/operations.rs
new file mode 100644
index 0000000000..471ef22a97
--- /dev/null
+++ b/services/svc/mixedreality/src/package_2021_01_01_preview/operations.rs
@@ -0,0 +1,718 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod remote_rendering {
+    use crate::models::*;
+    pub async fn get_conversion(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        conversion_id: &str,
+    ) -> std::result::Result<Conversion, get_conversion::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/accounts/{}/conversions/{}",
+            operation_config.base_path(),
+            account_id,
+            conversion_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_conversion::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_conversion::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_conversion::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_conversion::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Conversion =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(get_conversion::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(get_conversion::Error::Forbidden403 {}),
+            http::StatusCode::NOT_FOUND => Err(get_conversion::Error::NotFound404 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(get_conversion::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_conversion::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_conversion::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_conversion {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_conversion(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        conversion_id: &str,
+        body: &CreateConversionSettings,
+    ) -> std::result::Result<create_conversion::Response, create_conversion::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/accounts/{}/conversions/{}",
+            operation_config.base_path(),
+            account_id,
+            conversion_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_conversion::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_conversion::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_conversion::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_conversion::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_conversion::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Conversion = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_conversion::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: Conversion = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_conversion::Response::Created201(rsp_value))
+            }
+            http::StatusCode::BAD_REQUEST => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_conversion::Error::BadRequest400 { value: rsp_value })
+            }
+            http::StatusCode::UNAUTHORIZED => Err(create_conversion::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(create_conversion::Error::Forbidden403 {}),
+            http::StatusCode::CONFLICT => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_conversion::Error::Conflict409 { value: rsp_value })
+            }
+            http::StatusCode::TOO_MANY_REQUESTS => Err(create_conversion::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_conversion::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_conversion::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_conversion::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_conversion {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(Conversion),
+            Created201(Conversion),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            BadRequest400 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            Conflict409 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_conversions(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+    ) -> std::result::Result<ConversionList, list_conversions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/conversions", operation_config.base_path(), account_id);
+        let mut url = url::Url::parse(url_str).map_err(list_conversions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_conversions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_conversions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_conversions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ConversionList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_conversions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(list_conversions::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(list_conversions::Error::Forbidden403 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(list_conversions::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_conversions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_conversions::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_conversions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_conversions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_session(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        session_id: &str,
+    ) -> std::result::Result<SessionProperties, get_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/sessions/{}", operation_config.base_path(), account_id, session_id);
+        let mut url = url::Url::parse(url_str).map_err(get_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(get_session::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(get_session::Error::Forbidden403 {}),
+            http::StatusCode::NOT_FOUND => Err(get_session::Error::NotFound404 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(get_session::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_session::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_session(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        session_id: &str,
+        body: &CreateSessionSettings,
+    ) -> std::result::Result<create_session::Response, create_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/sessions/{}", operation_config.base_path(), account_id, session_id);
+        let mut url = url::Url::parse(url_str).map_err(create_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_session::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_session::Response::Created201(rsp_value))
+            }
+            http::StatusCode::BAD_REQUEST => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_session::Error::BadRequest400 { value: rsp_value })
+            }
+            http::StatusCode::UNAUTHORIZED => Err(create_session::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(create_session::Error::Forbidden403 {}),
+            http::StatusCode::CONFLICT => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_session::Error::Conflict409 { value: rsp_value })
+            }
+            http::StatusCode::TOO_MANY_REQUESTS => Err(create_session::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_session::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_session {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SessionProperties),
+            Created201(SessionProperties),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            BadRequest400 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            Conflict409 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update_session(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        session_id: &str,
+        body: &UpdateSessionSettings,
+    ) -> std::result::Result<SessionProperties, update_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/sessions/{}", operation_config.base_path(), account_id, session_id);
+        let mut url = url::Url::parse(url_str).map_err(update_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(update_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(update_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionProperties =
+                    serde_json::from_slice(rsp_body).map_err(|source| update_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(update_session::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(update_session::Error::Forbidden403 {}),
+            http::StatusCode::NOT_FOUND => Err(update_session::Error::NotFound404 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(update_session::Error::TooManyRequests429 {}),
+            http::StatusCode::UNPROCESSABLE_ENTITY => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| update_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_session::Error::UnprocessableEntity422 { value: rsp_value })
+            }
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| update_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update_session::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(update_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod update_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            UnprocessableEntity422 { value: models::ErrorResponse },
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn stop_session(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+        session_id: &str,
+    ) -> std::result::Result<(), stop_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/accounts/{}/sessions/{}/:stop",
+            operation_config.base_path(),
+            account_id,
+            session_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(stop_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(stop_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(stop_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(stop_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            http::StatusCode::UNAUTHORIZED => Err(stop_session::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(stop_session::Error::Forbidden403 {}),
+            http::StatusCode::NOT_FOUND => Err(stop_session::Error::NotFound404 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(stop_session::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| stop_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(stop_session::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(stop_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod stop_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_sessions(
+        operation_config: &crate::OperationConfig,
+        account_id: &str,
+    ) -> std::result::Result<SessionsList, list_sessions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/accounts/{}/sessions", operation_config.base_path(), account_id);
+        let mut url = url::Url::parse(url_str).map_err(list_sessions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_sessions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_sessions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_sessions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SessionsList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_sessions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::UNAUTHORIZED => Err(list_sessions::Error::Unauthorized401 {}),
+            http::StatusCode::FORBIDDEN => Err(list_sessions::Error::Forbidden403 {}),
+            http::StatusCode::TOO_MANY_REQUESTS => Err(list_sessions::Error::TooManyRequests429 {}),
+            http::StatusCode::INTERNAL_SERVER_ERROR => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_sessions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_sessions::Error::InternalServerError500 { value: rsp_value })
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list_sessions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list_sessions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Unauthorized401 {},
+            #[error("Error response #response_type")]
+            Forbidden403 {},
+            #[error("Error response #response_type")]
+            TooManyRequests429 {},
+            #[error("Error response #response_type")]
+            InternalServerError500 { value: models::ErrorResponse },
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/operationalinsights/Cargo.toml b/services/svc/operationalinsights/Cargo.toml
new file mode 100644
index 0000000000..a84a84b8d8
--- /dev/null
+++ b/services/svc/operationalinsights/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_operationalinsights"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["v1"]
+"v1" = []
diff --git a/services/svc/operationalinsights/src/lib.rs b/services/svc/operationalinsights/src/lib.rs
new file mode 100644
index 0000000000..a798e3294c
--- /dev/null
+++ b/services/svc/operationalinsights/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "v1")]
+mod v1;
+use azure_core::setters;
+#[cfg(feature = "v1")]
+pub use v1::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/operationalinsights/src/v1/mod.rs b/services/svc/operationalinsights/src/v1/mod.rs
new file mode 100644
index 0000000000..88083c7034
--- /dev/null
+++ b/services/svc/operationalinsights/src/v1/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "v1";
diff --git a/services/svc/operationalinsights/src/v1/models.rs b/services/svc/operationalinsights/src/v1/models.rs
new file mode 100644
index 0000000000..feb0643081
--- /dev/null
+++ b/services/svc/operationalinsights/src/v1/models.rs
@@ -0,0 +1,336 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryParam {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimespanParam {}
+pub type WorkspacesParam = Vec<String>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryBody {
+    pub query: QueryParam,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timespan: Option<TimespanParam>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub workspaces: Option<WorkspacesParam>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryResults {
+    pub tables: Vec<Table>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Table {
+    pub name: String,
+    pub columns: Vec<Column>,
+    pub rows: Vec<Vec<String>>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Column {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataResults {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub categories: Vec<MetadataCategory>,
+    #[serde(rename = "resourceTypes", default, skip_serializing_if = "Vec::is_empty")]
+    pub resource_types: Vec<MetadataResourceType>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub solutions: Vec<MetadataSolution>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tables: Vec<MetadataTable>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub functions: Vec<MetadataFunction>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub queries: Vec<MetadataQuery>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub applications: Vec<MetadataApplication>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub workspaces: Vec<MetadataWorkspace>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<MetadataResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub permissions: Vec<MetadataPermissions>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataCategory {
+    pub id: String,
+    #[serde(rename = "displayName")]
+    pub display_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<metadata_category::Related>,
+}
+pub mod metadata_category {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Related {
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub tables: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub functions: Vec<String>,
+        #[serde(rename = "resourceTypes", default, skip_serializing_if = "Vec::is_empty")]
+        pub resource_types: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub queries: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub solutions: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataSolution {
+    pub id: String,
+    pub name: String,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<Tags>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    pub related: metadata_solution::Related,
+}
+pub mod metadata_solution {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Related {
+        pub tables: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub functions: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub categories: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub queries: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub workspaces: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataResourceType {
+    pub id: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub labels: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<Tags>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<metadata_resource_type::Related>,
+}
+pub mod metadata_resource_type {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Related {
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub tables: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub functions: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub categories: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub queries: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub workspaces: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub resources: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataTable {
+    pub id: String,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "timespanColumn", default, skip_serializing_if = "Option::is_none")]
+    pub timespan_column: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub labels: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<Tags>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<metadata_table::Related>,
+}
+pub mod metadata_table {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Related {
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub categories: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub solutions: Vec<String>,
+        #[serde(rename = "resourceTypes", default, skip_serializing_if = "Vec::is_empty")]
+        pub resource_types: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub workspaces: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub functions: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub queries: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataFunction {
+    pub id: String,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<String>,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub body: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<Tags>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<metadata_function::Related>,
+}
+pub mod metadata_function {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Related {
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub tables: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub solutions: Vec<String>,
+        #[serde(rename = "resourceTypes", default, skip_serializing_if = "Vec::is_empty")]
+        pub resource_types: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub categories: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub workspaces: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataQuery {
+    pub id: String,
+    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub body: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub labels: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<Tags>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<metadata_query::Related>,
+}
+pub mod metadata_query {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Related {
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub categories: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub solutions: Vec<String>,
+        #[serde(rename = "resourceTypes", default, skip_serializing_if = "Vec::is_empty")]
+        pub resource_types: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub tables: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataApplication {
+    pub id: String,
+    #[serde(rename = "resourceId")]
+    pub resource_id: String,
+    pub name: String,
+    pub region: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<metadata_application::Related>,
+}
+pub mod metadata_application {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Related {
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub tables: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub functions: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataWorkspace {
+    pub id: String,
+    #[serde(rename = "resourceId")]
+    pub resource_id: String,
+    pub name: String,
+    pub region: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub related: Option<metadata_workspace::Related>,
+}
+pub mod metadata_workspace {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Related {
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub tables: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub solutions: Vec<String>,
+        #[serde(rename = "resourceTypes", default, skip_serializing_if = "Vec::is_empty")]
+        pub resource_types: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub functions: Vec<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        pub resources: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataResource {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataPermissions {
+    pub workspaces: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub applications: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Tags {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorDetail {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<String>,
+    #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+    pub additional_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorInfo {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub innererror: Box<Option<ErrorInfo>>,
+    #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+    pub additional_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    pub error: ErrorInfo,
+}
diff --git a/services/svc/operationalinsights/src/v1/operations.rs b/services/svc/operationalinsights/src/v1/operations.rs
new file mode 100644
index 0000000000..a3107cbe6d
--- /dev/null
+++ b/services/svc/operationalinsights/src/v1/operations.rs
@@ -0,0 +1,260 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod query {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        workspace_id: &str,
+        query: &str,
+        timespan: Option<&str>,
+    ) -> std::result::Result<QueryResults, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/workspaces/{}/query", operation_config.base_path(), workspace_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("query", query);
+        if let Some(timespan) = timespan {
+            url.query_pairs_mut().append_pair("timespan", timespan);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute(
+        operation_config: &crate::OperationConfig,
+        workspace_id: &str,
+        body: &QueryBody,
+    ) -> std::result::Result<QueryResults, execute::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/workspaces/{}/query", operation_config.base_path(), workspace_id);
+        let mut url = url::Url::parse(url_str).map_err(execute::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(body).map_err(execute::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod metadata {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, workspace_id: &str) -> std::result::Result<MetadataResults, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/workspaces/{}/metadata", operation_config.base_path(), workspace_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetadataResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn post(operation_config: &crate::OperationConfig, workspace_id: &str) -> std::result::Result<MetadataResults, post::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/workspaces/{}/metadata", operation_config.base_path(), workspace_id);
+        let mut url = url::Url::parse(url_str).map_err(post::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(post::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(post::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(post::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetadataResults =
+                    serde_json::from_slice(rsp_body).map_err(|source| post::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| post::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(post::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod post {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponse,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/purview/Cargo.toml b/services/svc/purview/Cargo.toml
new file mode 100644
index 0000000000..d25df85845
--- /dev/null
+++ b/services/svc/purview/Cargo.toml
@@ -0,0 +1,24 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_purview"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2018-12-01-preview"]
+"package-2018-12-01-preview" = []
+"package-2021-07-01-preview" = []
diff --git a/services/svc/purview/src/lib.rs b/services/svc/purview/src/lib.rs
new file mode 100644
index 0000000000..dcbf7eea7b
--- /dev/null
+++ b/services/svc/purview/src/lib.rs
@@ -0,0 +1,65 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2018-12-01-preview")]
+mod package_2018_12_01_preview;
+#[cfg(feature = "package-2018-12-01-preview")]
+pub use package_2018_12_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-07-01-preview")]
+mod package_2021_07_01_preview;
+use azure_core::setters;
+#[cfg(feature = "package-2021-07-01-preview")]
+pub use package_2021_07_01_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/purview/src/package_2018_12_01_preview/mod.rs b/services/svc/purview/src/package_2018_12_01_preview/mod.rs
new file mode 100644
index 0000000000..c76eee0f2e
--- /dev/null
+++ b/services/svc/purview/src/package_2018_12_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2018-12-01-preview";
diff --git a/services/svc/purview/src/package_2018_12_01_preview/models.rs b/services/svc/purview/src/package_2018_12_01_preview/models.rs
new file mode 100644
index 0000000000..0e4c24872e
--- /dev/null
+++ b/services/svc/purview/src/package_2018_12_01_preview/models.rs
@@ -0,0 +1,2466 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultProperties {
+    #[serde(rename = "baseUrl", default, skip_serializing_if = "Option::is_none")]
+    pub base_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProxyResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVault {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorModel {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorModel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponseModel {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<AzureKeyVault>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ClassificationRule {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    pub kind: classification_rule::Kind,
+}
+pub mod classification_rule {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        System,
+        Custom,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ClassificationRuleList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ClassificationRule>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OperationResponse {
+    #[serde(rename = "scanResultId", default, skip_serializing_if = "Option::is_none")]
+    pub scan_result_id: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<operation_response::Status>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<serde_json::Value>,
+}
+pub mod operation_response {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Accepted,
+        InProgress,
+        TransientFailure,
+        Succeeded,
+        Failed,
+        Canceled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Notification {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanDiagnostics {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub notifications: Vec<Notification>,
+    #[serde(rename = "exceptionCountMap", default, skip_serializing_if = "Option::is_none")]
+    pub exception_count_map: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanResult {
+    #[serde(rename = "parentId", default, skip_serializing_if = "Option::is_none")]
+    pub parent_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
+    pub resource_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "assetsDiscovered", default, skip_serializing_if = "Option::is_none")]
+    pub assets_discovered: Option<i64>,
+    #[serde(rename = "assetsClassified", default, skip_serializing_if = "Option::is_none")]
+    pub assets_classified: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub diagnostics: Option<serde_json::Value>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "queuedTime", default, skip_serializing_if = "Option::is_none")]
+    pub queued_time: Option<String>,
+    #[serde(rename = "pipelineStartTime", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(rename = "scanRulesetVersion", default, skip_serializing_if = "Option::is_none")]
+    pub scan_ruleset_version: Option<i32>,
+    #[serde(rename = "scanRulesetType", default, skip_serializing_if = "Option::is_none")]
+    pub scan_ruleset_type: Option<scan_result::ScanRulesetType>,
+    #[serde(rename = "scanLevelType", default, skip_serializing_if = "Option::is_none")]
+    pub scan_level_type: Option<scan_result::ScanLevelType>,
+    #[serde(rename = "errorMessage", default, skip_serializing_if = "Option::is_none")]
+    pub error_message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<serde_json::Value>,
+    #[serde(rename = "runType", default, skip_serializing_if = "Option::is_none")]
+    pub run_type: Option<String>,
+    #[serde(rename = "dataSourceType", default, skip_serializing_if = "Option::is_none")]
+    pub data_source_type: Option<scan_result::DataSourceType>,
+}
+pub mod scan_result {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ScanRulesetType {
+        Custom,
+        System,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ScanLevelType {
+        Full,
+        Incremental,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum DataSourceType {
+        None,
+        AzureSubscription,
+        AzureResourceGroup,
+        AzureSynapseWorkspace,
+        AzureSynapse,
+        AdlsGen1,
+        AdlsGen2,
+        AmazonAccount,
+        AmazonS3,
+        AmazonSql,
+        AzureCosmosDb,
+        AzureDataExplorer,
+        AzureFileService,
+        AzureSqlDatabase,
+        AmazonPostgreSql,
+        AzurePostgreSql,
+        SqlServerDatabase,
+        AzureSqlDatabaseManagedInstance,
+        AzureSqlDataWarehouse,
+        AzureMySql,
+        AzureStorage,
+        Teradata,
+        Oracle,
+        SapS4Hana,
+        SapEcc,
+        #[serde(rename = "PowerBI")]
+        PowerBi,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Scan {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    pub kind: scan::Kind,
+    #[serde(rename = "scanResults", default, skip_serializing_if = "Vec::is_empty")]
+    pub scan_results: Vec<ScanResult>,
+}
+pub mod scan {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        AzureSubscriptionCredential,
+        AzureSubscriptionMsi,
+        AzureResourceGroupCredential,
+        AzureResourceGroupMsi,
+        AzureSynapseWorkspaceCredential,
+        AzureSynapseWorkspaceMsi,
+        AzureSynapseCredential,
+        AzureSynapseMsi,
+        AdlsGen1Credential,
+        AdlsGen1Msi,
+        AdlsGen2Credential,
+        AdlsGen2Msi,
+        AmazonAccountCredential,
+        AmazonS3Credential,
+        #[serde(rename = "AmazonS3RoleARN")]
+        AmazonS3RoleArn,
+        AmazonSqlCredential,
+        AzureCosmosDbCredential,
+        AzureDataExplorerCredential,
+        AzureDataExplorerMsi,
+        AzureFileServiceCredential,
+        AzureSqlDatabaseCredential,
+        AzureSqlDatabaseMsi,
+        AmazonPostgreSqlCredential,
+        AzurePostgreSqlCredential,
+        SqlServerDatabaseCredential,
+        AzureSqlDatabaseManagedInstanceCredential,
+        AzureSqlDatabaseManagedInstanceMsi,
+        AzureSqlDataWarehouseCredential,
+        AzureSqlDataWarehouseMsi,
+        AzureMySqlCredential,
+        AzureStorageCredential,
+        AzureStorageMsi,
+        TeradataTeradataCredential,
+        TeradataTeradataUserPass,
+        TeradataUserPass,
+        OracleOracleCredential,
+        OracleOracleUserPass,
+        SapS4HanaSapS4HanaCredential,
+        SapS4HanaSapS4HanaUserPass,
+        SapEccSapEccCredential,
+        SapEccSapEccUserPass,
+        #[serde(rename = "PowerBIDelegated")]
+        PowerBiDelegated,
+        #[serde(rename = "PowerBIMsi")]
+        PowerBiMsi,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataSource {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    pub kind: data_source::Kind,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub scans: Vec<Scan>,
+}
+pub mod data_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        None,
+        AzureSubscription,
+        AzureResourceGroup,
+        AzureSynapseWorkspace,
+        AzureSynapse,
+        AdlsGen1,
+        AdlsGen2,
+        AmazonAccount,
+        AmazonS3,
+        AmazonSql,
+        AzureCosmosDb,
+        AzureDataExplorer,
+        AzureFileService,
+        AzureSqlDatabase,
+        AmazonPostgreSql,
+        AzurePostgreSql,
+        SqlServerDatabase,
+        AzureSqlDatabaseManagedInstance,
+        AzureSqlDataWarehouse,
+        AzureMySql,
+        AzureStorage,
+        Teradata,
+        Oracle,
+        SapS4Hana,
+        SapEcc,
+        #[serde(rename = "PowerBI")]
+        PowerBi,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataSourceList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<DataSource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterProperties {
+    #[serde(rename = "excludeUriPrefixes", default, skip_serializing_if = "Vec::is_empty")]
+    pub exclude_uri_prefixes: Vec<String>,
+    #[serde(rename = "includeUriPrefixes", default, skip_serializing_if = "Vec::is_empty")]
+    pub include_uri_prefixes: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Filter {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<Scan>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanHistoryList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ScanResult>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VersionedScanRuleset {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    #[serde(rename = "scanRulesetType", default, skip_serializing_if = "Option::is_none")]
+    pub scan_ruleset_type: Option<versioned_scan_ruleset::ScanRulesetType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<versioned_scan_ruleset::Status>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i32>,
+}
+pub mod versioned_scan_ruleset {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ScanRulesetType {
+        Custom,
+        System,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Enabled,
+        Disabled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanRuleset {
+    #[serde(flatten)]
+    pub versioned_scan_ruleset: VersionedScanRuleset,
+    pub kind: scan_ruleset::Kind,
+}
+pub mod scan_ruleset {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        None,
+        AzureSubscription,
+        AzureResourceGroup,
+        AzureSynapseWorkspace,
+        AzureSynapse,
+        AdlsGen1,
+        AdlsGen2,
+        AmazonAccount,
+        AmazonS3,
+        AmazonSql,
+        AzureCosmosDb,
+        AzureDataExplorer,
+        AzureFileService,
+        AzureSqlDatabase,
+        AmazonPostgreSql,
+        AzurePostgreSql,
+        SqlServerDatabase,
+        AzureSqlDatabaseManagedInstance,
+        AzureSqlDataWarehouse,
+        AzureMySql,
+        AzureStorage,
+        Teradata,
+        Oracle,
+        SapS4Hana,
+        SapEcc,
+        #[serde(rename = "PowerBI")]
+        PowerBi,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanRulesetList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ScanRuleset>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SystemScanRuleset {
+    #[serde(flatten)]
+    pub versioned_scan_ruleset: VersionedScanRuleset,
+    pub kind: system_scan_ruleset::Kind,
+}
+pub mod system_scan_ruleset {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        None,
+        AzureSubscription,
+        AzureResourceGroup,
+        AzureSynapseWorkspace,
+        AzureSynapse,
+        AdlsGen1,
+        AdlsGen2,
+        AmazonAccount,
+        AmazonS3,
+        AmazonSql,
+        AzureCosmosDb,
+        AzureDataExplorer,
+        AzureFileService,
+        AzureSqlDatabase,
+        AmazonPostgreSql,
+        AzurePostgreSql,
+        SqlServerDatabase,
+        AzureSqlDatabaseManagedInstance,
+        AzureSqlDataWarehouse,
+        AzureMySql,
+        AzureStorage,
+        Teradata,
+        Oracle,
+        SapS4Hana,
+        SapEcc,
+        #[serde(rename = "PowerBI")]
+        PowerBi,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SystemScanRulesetList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<SystemScanRuleset>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceScheduleOccurrence {
+    #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+    pub additional_properties: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub day: Option<recurrence_schedule_occurrence::Day>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub occurrence: Option<i32>,
+}
+pub mod recurrence_schedule_occurrence {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Day {
+        Sunday,
+        Monday,
+        Tuesday,
+        Wednesday,
+        Thursday,
+        Friday,
+        Saturday,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceSchedule {
+    #[serde(rename = "additionalProperties", default, skip_serializing_if = "Option::is_none")]
+    pub additional_properties: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub minutes: Vec<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub hours: Vec<i32>,
+    #[serde(rename = "weekDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub week_days: Vec<String>,
+    #[serde(rename = "monthDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub month_days: Vec<i32>,
+    #[serde(rename = "monthlyOccurrences", default, skip_serializing_if = "Vec::is_empty")]
+    pub monthly_occurrences: Vec<RecurrenceScheduleOccurrence>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRecurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub frequency: Option<trigger_recurrence::Frequency>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub interval: Option<i32>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule: Option<serde_json::Value>,
+    #[serde(rename = "timeZone", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone: Option<String>,
+}
+pub mod trigger_recurrence {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Frequency {
+        Week,
+        Month,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recurrence: Option<serde_json::Value>,
+    #[serde(rename = "recurrenceInterval", default, skip_serializing_if = "Option::is_none")]
+    pub recurrence_interval: Option<String>,
+    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
+    pub created_at: Option<String>,
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+    #[serde(rename = "lastScheduled", default, skip_serializing_if = "Option::is_none")]
+    pub last_scheduled: Option<String>,
+    #[serde(rename = "scanLevel", default, skip_serializing_if = "Option::is_none")]
+    pub scan_level: Option<trigger_properties::ScanLevel>,
+    #[serde(rename = "incrementalScanStartTime", default, skip_serializing_if = "Option::is_none")]
+    pub incremental_scan_start_time: Option<String>,
+}
+pub mod trigger_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ScanLevel {
+        Full,
+        Incremental,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Trigger {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CollectionReference {
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+    #[serde(rename = "referenceName", default, skip_serializing_if = "Option::is_none")]
+    pub reference_name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SystemClassificationRuleProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i32>,
+    #[serde(rename = "classificationName", default, skip_serializing_if = "Option::is_none")]
+    pub classification_name: Option<String>,
+    #[serde(rename = "ruleStatus", default, skip_serializing_if = "Option::is_none")]
+    pub rule_status: Option<system_classification_rule_properties::RuleStatus>,
+    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
+    pub created_at: Option<String>,
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+}
+pub mod system_classification_rule_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum RuleStatus {
+        Enabled,
+        Disabled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SystemClassificationRule {
+    #[serde(flatten)]
+    pub classification_rule: ClassificationRule,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ClassificationRulePattern {
+    pub kind: classification_rule_pattern::Kind,
+}
+pub mod classification_rule_pattern {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        Regex,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomClassificationRuleProperties {
+    #[serde(rename = "minimumPercentageMatch", default, skip_serializing_if = "Option::is_none")]
+    pub minimum_percentage_match: Option<f64>,
+    #[serde(rename = "classificationAction", default, skip_serializing_if = "Option::is_none")]
+    pub classification_action: Option<custom_classification_rule_properties::ClassificationAction>,
+    #[serde(rename = "dataPatterns", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_patterns: Vec<ClassificationRulePattern>,
+    #[serde(rename = "columnPatterns", default, skip_serializing_if = "Vec::is_empty")]
+    pub column_patterns: Vec<ClassificationRulePattern>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i32>,
+    #[serde(rename = "classificationName", default, skip_serializing_if = "Option::is_none")]
+    pub classification_name: Option<String>,
+    #[serde(rename = "ruleStatus", default, skip_serializing_if = "Option::is_none")]
+    pub rule_status: Option<custom_classification_rule_properties::RuleStatus>,
+    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
+    pub created_at: Option<String>,
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+}
+pub mod custom_classification_rule_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ClassificationAction {
+        Keep,
+        Delete,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum RuleStatus {
+        Enabled,
+        Disabled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomClassificationRule {
+    #[serde(flatten)]
+    pub classification_rule: ClassificationRule,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RegexClassificationRulePattern {
+    #[serde(flatten)]
+    pub classification_rule_pattern: ClassificationRulePattern,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pattern: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataSourceProperties {
+    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
+    pub created_at: Option<String>,
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collection: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataSourceProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "resourceGroup", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group: Option<String>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    #[serde(rename = "resourceName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "dedicatedSqlEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub dedicated_sql_endpoint: Option<String>,
+    #[serde(rename = "serverlessSqlEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub serverless_sql_endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "sqlEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub sql_endpoint: Option<String>,
+    #[serde(rename = "sqlOnDemandEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub sql_on_demand_endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1Properties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1DataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2Properties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2DataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonAccountProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "awsAccountId", default, skip_serializing_if = "Option::is_none")]
+    pub aws_account_id: Option<String>,
+    #[serde(rename = "roleARN", default, skip_serializing_if = "Option::is_none")]
+    pub role_arn: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonAccountDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Properties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<String>,
+    #[serde(rename = "roleARN", default, skip_serializing_if = "Option::is_none")]
+    pub role_arn: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3DataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonSqlProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonSqlDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureCosmosDbProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "accountUri", default, skip_serializing_if = "Option::is_none")]
+    pub account_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureCosmosDbDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileServiceProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileServiceDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonPostgreSqlProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonPostgreSqlDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerDatabaseProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerDatabaseDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageProperties {
+    #[serde(flatten)]
+    pub azure_data_source_properties: AzureDataSourceProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub endpoint: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub host: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub host: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub service: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "applicationServer", default, skip_serializing_if = "Option::is_none")]
+    pub application_server: Option<String>,
+    #[serde(rename = "systemNumber", default, skip_serializing_if = "Option::is_none")]
+    pub system_number: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(rename = "applicationServer", default, skip_serializing_if = "Option::is_none")]
+    pub application_server: Option<String>,
+    #[serde(rename = "systemNumber", default, skip_serializing_if = "Option::is_none")]
+    pub system_number: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiProperties {
+    #[serde(flatten)]
+    pub data_source_properties: DataSourceProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiDataSource {
+    #[serde(flatten)]
+    pub data_source: DataSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanRulesetProperties {
+    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
+    pub created_at: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "excludedSystemClassifications", default, skip_serializing_if = "Vec::is_empty")]
+    pub excluded_system_classifications: Vec<String>,
+    #[serde(rename = "includedCustomClassificationRuleNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub included_custom_classification_rule_names: Vec<String>,
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomFileType {
+    #[serde(rename = "builtInType", default, skip_serializing_if = "Option::is_none")]
+    pub built_in_type: Option<custom_file_type::BuiltInType>,
+    #[serde(rename = "customDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub custom_delimiter: Option<String>,
+}
+pub mod custom_file_type {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum BuiltInType {
+        #[serde(rename = "AVRO")]
+        Avro,
+        #[serde(rename = "ORC")]
+        Orc,
+        #[serde(rename = "PARQUET")]
+        Parquet,
+        #[serde(rename = "JSON")]
+        Json,
+        #[serde(rename = "TXT")]
+        Txt,
+        #[serde(rename = "XML")]
+        Xml,
+        Documents,
+        #[serde(rename = "CSV")]
+        Csv,
+        #[serde(rename = "PSV")]
+        Psv,
+        #[serde(rename = "SSV")]
+        Ssv,
+        #[serde(rename = "TSV")]
+        Tsv,
+        #[serde(rename = "GZ")]
+        Gz,
+        #[serde(rename = "DOC")]
+        Doc,
+        #[serde(rename = "DOCM")]
+        Docm,
+        #[serde(rename = "DOCX")]
+        Docx,
+        #[serde(rename = "DOT")]
+        Dot,
+        #[serde(rename = "ODP")]
+        Odp,
+        #[serde(rename = "ODS")]
+        Ods,
+        #[serde(rename = "ODT")]
+        Odt,
+        #[serde(rename = "PDF")]
+        Pdf,
+        #[serde(rename = "POT")]
+        Pot,
+        #[serde(rename = "PPS")]
+        Pps,
+        #[serde(rename = "PPSX")]
+        Ppsx,
+        #[serde(rename = "PPT")]
+        Ppt,
+        #[serde(rename = "PPTM")]
+        Pptm,
+        #[serde(rename = "PPTX")]
+        Pptx,
+        #[serde(rename = "XLC")]
+        Xlc,
+        #[serde(rename = "XLS")]
+        Xls,
+        #[serde(rename = "XLSB")]
+        Xlsb,
+        #[serde(rename = "XLSM")]
+        Xlsm,
+        #[serde(rename = "XLSX")]
+        Xlsx,
+        #[serde(rename = "XLT")]
+        Xlt,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomFileExtension {
+    #[serde(rename = "customFileType", default, skip_serializing_if = "Option::is_none")]
+    pub custom_file_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(rename = "fileExtension", default, skip_serializing_if = "Option::is_none")]
+    pub file_extension: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanningRule {
+    #[serde(rename = "fileExtensions", default, skip_serializing_if = "Vec::is_empty")]
+    pub file_extensions: Vec<String>,
+    #[serde(rename = "customFileExtensions", default, skip_serializing_if = "Vec::is_empty")]
+    pub custom_file_extensions: Vec<CustomFileExtension>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanningRuleScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+    #[serde(rename = "scanningRule", default, skip_serializing_if = "Option::is_none")]
+    pub scanning_rule: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1ScanRulesetProperties {
+    #[serde(flatten)]
+    pub scanning_rule_scan_ruleset_properties: ScanningRuleScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1ScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2ScanRulesetProperties {
+    #[serde(flatten)]
+    pub scanning_rule_scan_ruleset_properties: ScanningRuleScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2ScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonAccountScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonAccountScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3ScanRulesetProperties {
+    #[serde(flatten)]
+    pub scanning_rule_scan_ruleset_properties: ScanningRuleScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3ScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonSqlScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonSqlScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureCosmosDbScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureCosmosDbScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileServiceScanRulesetProperties {
+    #[serde(flatten)]
+    pub scanning_rule_scan_ruleset_properties: ScanningRuleScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileServiceScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonPostgreSqlScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonPostgreSqlScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerDatabaseScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerDatabaseScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageScanRulesetProperties {
+    #[serde(flatten)]
+    pub scanning_rule_scan_ruleset_properties: ScanningRuleScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiScanRulesetProperties {
+    #[serde(flatten)]
+    pub scan_ruleset_properties: ScanRulesetProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiScanRuleset {
+    #[serde(flatten)]
+    pub scan_ruleset: ScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceNameFilter {
+    #[serde(rename = "excludePrefixes", default, skip_serializing_if = "Vec::is_empty")]
+    pub exclude_prefixes: Vec<String>,
+    #[serde(rename = "includePrefixes", default, skip_serializing_if = "Vec::is_empty")]
+    pub include_prefixes: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub resources: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CredentialReference {
+    #[serde(rename = "referenceName", default, skip_serializing_if = "Option::is_none")]
+    pub reference_name: Option<String>,
+    #[serde(rename = "credentialType", default, skip_serializing_if = "Option::is_none")]
+    pub credential_type: Option<credential_reference::CredentialType>,
+}
+pub mod credential_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CredentialType {
+        AccountKey,
+        ServicePrincipal,
+        BasicAuth,
+        SqlAuth,
+        #[serde(rename = "AmazonARN")]
+        AmazonArn,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResourceTypeFilter {
+    #[serde(rename = "scanRulesetName", default, skip_serializing_if = "Option::is_none")]
+    pub scan_ruleset_name: Option<String>,
+    #[serde(rename = "scanRulesetType", default, skip_serializing_if = "Option::is_none")]
+    pub scan_ruleset_type: Option<resource_type_filter::ScanRulesetType>,
+    #[serde(rename = "resourceNameFilter", default, skip_serializing_if = "Option::is_none")]
+    pub resource_name_filter: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+}
+pub mod resource_type_filter {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ScanRulesetType {
+        Custom,
+        System,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConnectedVia {
+    #[serde(rename = "referenceName", default, skip_serializing_if = "Option::is_none")]
+    pub reference_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScanProperties {
+    #[serde(rename = "scanRulesetName", default, skip_serializing_if = "Option::is_none")]
+    pub scan_ruleset_name: Option<String>,
+    #[serde(rename = "scanRulesetType", default, skip_serializing_if = "Option::is_none")]
+    pub scan_ruleset_type: Option<scan_properties::ScanRulesetType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collection: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub workers: Option<i32>,
+    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
+    pub created_at: Option<String>,
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+    #[serde(rename = "connectedVia", default, skip_serializing_if = "Option::is_none")]
+    pub connected_via: Option<serde_json::Value>,
+}
+pub mod scan_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ScanRulesetType {
+        Custom,
+        System,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExpandingResourceScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(rename = "resourceTypes", default, skip_serializing_if = "Option::is_none")]
+    pub resource_types: Option<expanding_resource_scan_properties::ResourceTypes>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+}
+pub mod expanding_resource_scan_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct ResourceTypes {
+        #[serde(rename = "None", default, skip_serializing_if = "Option::is_none")]
+        pub none: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureSubscription", default, skip_serializing_if = "Option::is_none")]
+        pub azure_subscription: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureResourceGroup", default, skip_serializing_if = "Option::is_none")]
+        pub azure_resource_group: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureSynapseWorkspace", default, skip_serializing_if = "Option::is_none")]
+        pub azure_synapse_workspace: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureSynapse", default, skip_serializing_if = "Option::is_none")]
+        pub azure_synapse: Option<ResourceTypeFilter>,
+        #[serde(rename = "AdlsGen1", default, skip_serializing_if = "Option::is_none")]
+        pub adls_gen1: Option<ResourceTypeFilter>,
+        #[serde(rename = "AdlsGen2", default, skip_serializing_if = "Option::is_none")]
+        pub adls_gen2: Option<ResourceTypeFilter>,
+        #[serde(rename = "AmazonAccount", default, skip_serializing_if = "Option::is_none")]
+        pub amazon_account: Option<ResourceTypeFilter>,
+        #[serde(rename = "AmazonS3", default, skip_serializing_if = "Option::is_none")]
+        pub amazon_s3: Option<ResourceTypeFilter>,
+        #[serde(rename = "AmazonSql", default, skip_serializing_if = "Option::is_none")]
+        pub amazon_sql: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureCosmosDb", default, skip_serializing_if = "Option::is_none")]
+        pub azure_cosmos_db: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureDataExplorer", default, skip_serializing_if = "Option::is_none")]
+        pub azure_data_explorer: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureFileService", default, skip_serializing_if = "Option::is_none")]
+        pub azure_file_service: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureSqlDatabase", default, skip_serializing_if = "Option::is_none")]
+        pub azure_sql_database: Option<ResourceTypeFilter>,
+        #[serde(rename = "AmazonPostgreSql", default, skip_serializing_if = "Option::is_none")]
+        pub amazon_postgre_sql: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzurePostgreSql", default, skip_serializing_if = "Option::is_none")]
+        pub azure_postgre_sql: Option<ResourceTypeFilter>,
+        #[serde(rename = "SqlServerDatabase", default, skip_serializing_if = "Option::is_none")]
+        pub sql_server_database: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureSqlDatabaseManagedInstance", default, skip_serializing_if = "Option::is_none")]
+        pub azure_sql_database_managed_instance: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureSqlDataWarehouse", default, skip_serializing_if = "Option::is_none")]
+        pub azure_sql_data_warehouse: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureMySql", default, skip_serializing_if = "Option::is_none")]
+        pub azure_my_sql: Option<ResourceTypeFilter>,
+        #[serde(rename = "AzureStorage", default, skip_serializing_if = "Option::is_none")]
+        pub azure_storage: Option<ResourceTypeFilter>,
+        #[serde(rename = "Teradata", default, skip_serializing_if = "Option::is_none")]
+        pub teradata: Option<ResourceTypeFilter>,
+        #[serde(rename = "Oracle", default, skip_serializing_if = "Option::is_none")]
+        pub oracle: Option<ResourceTypeFilter>,
+        #[serde(rename = "SapS4Hana", default, skip_serializing_if = "Option::is_none")]
+        pub sap_s4_hana: Option<ResourceTypeFilter>,
+        #[serde(rename = "SapEcc", default, skip_serializing_if = "Option::is_none")]
+        pub sap_ecc: Option<ResourceTypeFilter>,
+        #[serde(rename = "PowerBI", default, skip_serializing_if = "Option::is_none")]
+        pub power_bi: Option<ResourceTypeFilter>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionCredentialScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionMsiScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupCredentialScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupMsiScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceCredentialScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceMsiScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseCredentialScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseMsiScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1CredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1CredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1MsiScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1MsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2CredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2CredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2MsiScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2MsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonAccountCredentialScanProperties {
+    #[serde(flatten)]
+    pub expanding_resource_scan_properties: ExpandingResourceScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonAccountCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3CredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(rename = "roleARN", default, skip_serializing_if = "Option::is_none")]
+    pub role_arn: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3CredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3RoleArnScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(rename = "roleARN", default, skip_serializing_if = "Option::is_none")]
+    pub role_arn: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3RoleArnScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonSqlCredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonSqlCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureCosmosDbCredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureCosmosDbCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerMsiScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileServiceCredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(rename = "shareName", default, skip_serializing_if = "Option::is_none")]
+    pub share_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileServiceCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlCredentialScanProperties {
+    #[serde(flatten)]
+    pub azure_sql_scan_properties: AzureSqlScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseCredentialScanProperties {
+    #[serde(flatten)]
+    pub azure_sql_credential_scan_properties: AzureSqlCredentialScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseMsiScanProperties {
+    #[serde(flatten)]
+    pub azure_sql_scan_properties: AzureSqlScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonPostgreSqlCredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonPostgreSqlCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlCredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<i32>,
+    #[serde(rename = "sslMode", default, skip_serializing_if = "Option::is_none")]
+    pub ssl_mode: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerDatabaseCredentialScanProperties {
+    #[serde(flatten)]
+    pub azure_sql_credential_scan_properties: AzureSqlCredentialScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerDatabaseCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceCredentialScanProperties {
+    #[serde(flatten)]
+    pub azure_sql_credential_scan_properties: AzureSqlCredentialScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceMsiScanProperties {
+    #[serde(flatten)]
+    pub azure_sql_scan_properties: AzureSqlScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseCredentialScanProperties {
+    #[serde(flatten)]
+    pub azure_sql_credential_scan_properties: AzureSqlCredentialScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseMsiScanProperties {
+    #[serde(flatten)]
+    pub azure_sql_scan_properties: AzureSqlScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(rename = "serverEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub server_endpoint: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<i32>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlCredentialScanProperties {
+    #[serde(flatten)]
+    pub azure_my_sql_scan_properties: AzureMySqlScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MitiScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(rename = "maximumMemoryAllowedInGb", default, skip_serializing_if = "Option::is_none")]
+    pub maximum_memory_allowed_in_gb: Option<String>,
+    #[serde(rename = "mitiCache", default, skip_serializing_if = "Option::is_none")]
+    pub miti_cache: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageCredentialScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageMsiScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTeradataCredentialScanProperties {
+    #[serde(flatten)]
+    pub miti_scan_properties: MitiScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    #[serde(rename = "driverLocation", default, skip_serializing_if = "Option::is_none")]
+    pub driver_location: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTeradataCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataUserPassScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataUserPassScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTeradataUserPassScanProperties {
+    #[serde(flatten)]
+    pub miti_scan_properties: MitiScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    #[serde(rename = "driverLocation", default, skip_serializing_if = "Option::is_none")]
+    pub driver_location: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTeradataUserPassScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleOracleCredentialScanProperties {
+    #[serde(flatten)]
+    pub miti_scan_properties: MitiScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    #[serde(rename = "driverLocation", default, skip_serializing_if = "Option::is_none")]
+    pub driver_location: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleOracleCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleOracleUserPassScanProperties {
+    #[serde(flatten)]
+    pub miti_scan_properties: MitiScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    #[serde(rename = "driverLocation", default, skip_serializing_if = "Option::is_none")]
+    pub driver_location: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleOracleUserPassScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaSapS4HanaCredentialScanProperties {
+    #[serde(flatten)]
+    pub miti_scan_properties: MitiScanProperties,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(rename = "jCoLibraryPath", default, skip_serializing_if = "Option::is_none")]
+    pub j_co_library_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaSapS4HanaCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaSapS4HanaUserPassScanProperties {
+    #[serde(flatten)]
+    pub miti_scan_properties: MitiScanProperties,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+    #[serde(rename = "jCoLibraryPath", default, skip_serializing_if = "Option::is_none")]
+    pub j_co_library_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaSapS4HanaUserPassScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSapEccCredentialScanProperties {
+    #[serde(flatten)]
+    pub miti_scan_properties: MitiScanProperties,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<serde_json::Value>,
+    #[serde(rename = "jCoLibraryPath", default, skip_serializing_if = "Option::is_none")]
+    pub j_co_library_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSapEccCredentialScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSapEccUserPassScanProperties {
+    #[serde(flatten)]
+    pub miti_scan_properties: MitiScanProperties,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+    #[serde(rename = "jCoLibraryPath", default, skip_serializing_if = "Option::is_none")]
+    pub j_co_library_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSapEccUserPassScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiDelegatedScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<String>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<String>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<String>,
+    #[serde(rename = "includePersonalWorkspaces", default, skip_serializing_if = "Option::is_none")]
+    pub include_personal_workspaces: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiDelegatedScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiMsiScanProperties {
+    #[serde(flatten)]
+    pub scan_properties: ScanProperties,
+    #[serde(rename = "includePersonalWorkspaces", default, skip_serializing_if = "Option::is_none")]
+    pub include_personal_workspaces: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiMsiScan {
+    #[serde(flatten)]
+    pub scan: Scan,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSubscriptionSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureResourceGroupSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseWorkspaceSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSynapseSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen1SystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdlsGen2SystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonAccountSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3SystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonSqlSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureCosmosDbSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileServiceSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonPostgreSqlSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerDatabaseSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseManagedInstanceSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDataWarehouseSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapS4HanaSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PowerBiSystemScanRuleset {
+    #[serde(flatten)]
+    pub system_scan_ruleset: SystemScanRuleset,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+}
diff --git a/services/svc/purview/src/package_2018_12_01_preview/operations.rs b/services/svc/purview/src/package_2018_12_01_preview/operations.rs
new file mode 100644
index 0000000000..8fc0141052
--- /dev/null
+++ b/services/svc/purview/src/package_2018_12_01_preview/operations.rs
@@ -0,0 +1,2477 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod key_vault_connections {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, key_vault_name: &str) -> std::result::Result<AzureKeyVault, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/azureKeyVaults/{}", operation_config.base_path(), key_vault_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AzureKeyVault =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        key_vault_name: &str,
+        body: &AzureKeyVault,
+    ) -> std::result::Result<AzureKeyVault, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/azureKeyVaults/{}", operation_config.base_path(), key_vault_name);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AzureKeyVault =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        key_vault_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/azureKeyVaults/{}", operation_config.base_path(), key_vault_name);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AzureKeyVault =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(AzureKeyVault),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_all(operation_config: &crate::OperationConfig) -> std::result::Result<AzureKeyVaultList, list_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/azureKeyVaults", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AzureKeyVaultList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod classification_rules {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        classification_rule_name: &str,
+    ) -> std::result::Result<ClassificationRule, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/classificationrules/{}", operation_config.base_path(), classification_rule_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ClassificationRule =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        classification_rule_name: &str,
+        body: Option<&ClassificationRule>,
+    ) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/classificationrules/{}", operation_config.base_path(), classification_rule_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = if let Some(body) = body {
+            azure_core::to_json(body).map_err(create_or_update::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ClassificationRule = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: ClassificationRule = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Created201(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(ClassificationRule),
+            Created201(ClassificationRule),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        classification_rule_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/classificationrules/{}", operation_config.base_path(), classification_rule_name);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ClassificationRule =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(ClassificationRule),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_all(operation_config: &crate::OperationConfig) -> std::result::Result<ClassificationRuleList, list_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/classificationrules", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ClassificationRuleList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_versions_by_classification_rule_name(
+        operation_config: &crate::OperationConfig,
+        classification_rule_name: &str,
+    ) -> std::result::Result<ClassificationRuleList, list_versions_by_classification_rule_name::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/classificationrules/{}/versions",
+            operation_config.base_path(),
+            classification_rule_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_versions_by_classification_rule_name::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_versions_by_classification_rule_name::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_versions_by_classification_rule_name::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_versions_by_classification_rule_name::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ClassificationRuleList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_versions_by_classification_rule_name::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_versions_by_classification_rule_name::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_versions_by_classification_rule_name::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_versions_by_classification_rule_name {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn tag_classification_version(
+        operation_config: &crate::OperationConfig,
+        classification_rule_name: &str,
+        classification_rule_version: i32,
+        action: &str,
+    ) -> std::result::Result<OperationResponse, tag_classification_version::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/classificationrules/{}/versions/{}/:tag",
+            operation_config.base_path(),
+            classification_rule_name,
+            classification_rule_version
+        );
+        let mut url = url::Url::parse(url_str).map_err(tag_classification_version::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(tag_classification_version::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        url.query_pairs_mut().append_pair("action", action);
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(tag_classification_version::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(tag_classification_version::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: OperationResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| tag_classification_version::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| tag_classification_version::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(tag_classification_version::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod tag_classification_version {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_sources {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, data_source_name: &str) -> std::result::Result<DataSource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasources/{}", operation_config.base_path(), data_source_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataSource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        body: Option<&DataSource>,
+    ) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasources/{}", operation_config.base_path(), data_source_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = if let Some(body) = body {
+            azure_core::to_json(body).map_err(create_or_update::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataSource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataSource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Created201(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DataSource),
+            Created201(DataSource),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasources/{}", operation_config.base_path(), data_source_name);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataSource =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DataSource),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_all(operation_config: &crate::OperationConfig) -> std::result::Result<DataSourceList, list_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasources", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataSourceList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod filters {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+    ) -> std::result::Result<Filter, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}/filters/custom",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Filter =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+        body: Option<&Filter>,
+    ) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}/filters/custom",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = if let Some(body) = body {
+            azure_core::to_json(body).map_err(create_or_update::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Filter = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: Filter = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Created201(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(Filter),
+            Created201(Filter),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod scans {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+    ) -> std::result::Result<Scan, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Scan =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+        body: &Scan,
+    ) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_or_update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Scan = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: Scan = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Created201(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(Scan),
+            Created201(Scan),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Scan =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(Scan),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_by_data_source(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+    ) -> std::result::Result<ScanList, list_by_data_source::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasources/{}/scans", operation_config.base_path(), data_source_name);
+        let mut url = url::Url::parse(url_str).map_err(list_by_data_source::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_by_data_source::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_by_data_source::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_by_data_source::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ScanList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_by_data_source::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_by_data_source::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_by_data_source::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_by_data_source {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod scan_result {
+    use crate::models::*;
+    pub async fn run_scan(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+        run_id: &str,
+        scan_level: Option<&str>,
+    ) -> std::result::Result<OperationResponse, run_scan::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}/runs/{}",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(run_scan::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(run_scan::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(scan_level) = scan_level {
+            url.query_pairs_mut().append_pair("scanLevel", scan_level);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(run_scan::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(run_scan::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: OperationResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| run_scan::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| run_scan::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(run_scan::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod run_scan {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_scan(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<OperationResponse, cancel_scan::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}/runs/{}/:cancel",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_scan::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_scan::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel_scan::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_scan::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: OperationResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| cancel_scan::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| cancel_scan::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_scan::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_scan {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_scan_history(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+    ) -> std::result::Result<ScanHistoryList, list_scan_history::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}/runs",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list_scan_history::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_scan_history::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_scan_history::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_scan_history::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ScanHistoryList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_scan_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_scan_history::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_scan_history::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_scan_history {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod scan_rulesets {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, scan_ruleset_name: &str) -> std::result::Result<ScanRuleset, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/scanrulesets/{}", operation_config.base_path(), scan_ruleset_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ScanRuleset =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        scan_ruleset_name: &str,
+        body: Option<&ScanRuleset>,
+    ) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/scanrulesets/{}", operation_config.base_path(), scan_ruleset_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = if let Some(body) = body {
+            azure_core::to_json(body).map_err(create_or_update::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ScanRuleset = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: ScanRuleset = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Created201(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(ScanRuleset),
+            Created201(ScanRuleset),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        scan_ruleset_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/scanrulesets/{}", operation_config.base_path(), scan_ruleset_name);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ScanRuleset =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(ScanRuleset),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_all(operation_config: &crate::OperationConfig) -> std::result::Result<ScanRulesetList, list_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/scanrulesets", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ScanRulesetList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod system_scan_rulesets {
+    use crate::models::*;
+    pub async fn list_all(operation_config: &crate::OperationConfig) -> std::result::Result<SystemScanRulesetList, list_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/systemScanRulesets", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SystemScanRulesetList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        data_source_type: &str,
+    ) -> std::result::Result<SystemScanRuleset, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/systemScanRulesets/datasources/{}",
+            operation_config.base_path(),
+            data_source_type
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SystemScanRuleset =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_by_version(
+        operation_config: &crate::OperationConfig,
+        data_source_type: Option<&str>,
+        version: i32,
+    ) -> std::result::Result<SystemScanRuleset, get_by_version::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/systemScanRulesets/versions/{}", operation_config.base_path(), version);
+        let mut url = url::Url::parse(url_str).map_err(get_by_version::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_by_version::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(data_source_type) = data_source_type {
+            url.query_pairs_mut().append_pair("dataSourceType", data_source_type);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_by_version::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_by_version::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SystemScanRuleset =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_by_version::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_by_version::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_by_version::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_by_version {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_latest(
+        operation_config: &crate::OperationConfig,
+        data_source_type: Option<&str>,
+    ) -> std::result::Result<SystemScanRuleset, get_latest::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/systemScanRulesets/versions/latest", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_latest::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_latest::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(data_source_type) = data_source_type {
+            url.query_pairs_mut().append_pair("dataSourceType", data_source_type);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_latest::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_latest::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SystemScanRuleset =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_latest::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_latest::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_latest::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_latest {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_versions_by_data_source(
+        operation_config: &crate::OperationConfig,
+        data_source_type: Option<&str>,
+    ) -> std::result::Result<SystemScanRulesetList, list_versions_by_data_source::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/systemScanRulesets/versions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_versions_by_data_source::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_versions_by_data_source::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(data_source_type) = data_source_type {
+            url.query_pairs_mut().append_pair("dataSourceType", data_source_type);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_versions_by_data_source::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_versions_by_data_source::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SystemScanRulesetList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_versions_by_data_source::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_versions_by_data_source::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_versions_by_data_source::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_versions_by_data_source {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod triggers {
+    use crate::models::*;
+    pub async fn get_trigger(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+    ) -> std::result::Result<Trigger, get_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}/triggers/default",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Trigger =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_trigger(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+        body: &Trigger,
+    ) -> std::result::Result<create_trigger::Response, create_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}/triggers/default",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(body).map_err(create_trigger::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Trigger =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_trigger::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: Trigger =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_trigger::Response::Created201(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| create_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(Trigger),
+            Created201(Trigger),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_trigger(
+        operation_config: &crate::OperationConfig,
+        data_source_name: &str,
+        scan_name: &str,
+    ) -> std::result::Result<delete_trigger::Response, delete_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/datasources/{}/scans/{}/triggers/default",
+            operation_config.base_path(),
+            data_source_name,
+            scan_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Trigger =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete_trigger::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(delete_trigger::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(Trigger),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/purview/src/package_2021_07_01_preview/mod.rs b/services/svc/purview/src/package_2021_07_01_preview/mod.rs
new file mode 100644
index 0000000000..855c1a407f
--- /dev/null
+++ b/services/svc/purview/src/package_2021_07_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-07-01-preview";
diff --git a/services/svc/purview/src/package_2021_07_01_preview/models.rs b/services/svc/purview/src/package_2021_07_01_preview/models.rs
new file mode 100644
index 0000000000..8f526d500f
--- /dev/null
+++ b/services/svc/purview/src/package_2021_07_01_preview/models.rs
@@ -0,0 +1,144 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttributeMatcher {
+    #[serde(rename = "attributeName", default, skip_serializing_if = "Option::is_none")]
+    pub attribute_name: Option<String>,
+    #[serde(rename = "attributeValueIncludes", default, skip_serializing_if = "Option::is_none")]
+    pub attribute_value_includes: Option<String>,
+    #[serde(rename = "attributeValueIncludedIn", default, skip_serializing_if = "Vec::is_empty")]
+    pub attribute_value_included_in: Vec<String>,
+    #[serde(rename = "attributeValueExcludes", default, skip_serializing_if = "Option::is_none")]
+    pub attribute_value_excludes: Option<String>,
+    #[serde(rename = "attributeValueExcludedIn", default, skip_serializing_if = "Vec::is_empty")]
+    pub attribute_value_excluded_in: Vec<String>,
+}
+pub type DnfCondition = Vec<Vec<AttributeMatcher>>;
+pub type CnfCondition = Vec<Vec<AttributeMatcher>>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DecisionRule {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<decision_rule::Kind>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub effect: Option<decision_rule::Effect>,
+    #[serde(rename = "dnfCondition", default, skip_serializing_if = "Option::is_none")]
+    pub dnf_condition: Option<DnfCondition>,
+}
+pub mod decision_rule {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        #[serde(rename = "decisionrule")]
+        Decisionrule,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Effect {
+        Deny,
+        Permit,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AttributeRule {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<attribute_rule::Kind>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "dnfCondition", default, skip_serializing_if = "Option::is_none")]
+    pub dnf_condition: Option<DnfCondition>,
+}
+pub mod attribute_rule {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        #[serde(rename = "attributerule")]
+        Attributerule,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CollectionReference {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "referenceName", default, skip_serializing_if = "Option::is_none")]
+    pub reference_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataPolicyProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "decisionRules", default, skip_serializing_if = "Vec::is_empty")]
+    pub decision_rules: Vec<DecisionRule>,
+    #[serde(rename = "attributeRules", default, skip_serializing_if = "Vec::is_empty")]
+    pub attribute_rules: Vec<AttributeRule>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collection: Option<CollectionReference>,
+    #[serde(rename = "parentCollectionName", default, skip_serializing_if = "Option::is_none")]
+    pub parent_collection_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<MetadataPolicyProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorModel {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorModel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponseModel {
+    pub error: ErrorModel,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataPolicyList {
+    pub values: Vec<MetadataPolicy>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataRoleProperties {
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "roleType", default, skip_serializing_if = "Option::is_none")]
+    pub role_type: Option<String>,
+    #[serde(rename = "friendlyName", default, skip_serializing_if = "Option::is_none")]
+    pub friendly_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "cnfCondition", default, skip_serializing_if = "Option::is_none")]
+    pub cnf_condition: Option<CnfCondition>,
+    #[serde(rename = "dnfCondition", default, skip_serializing_if = "Option::is_none")]
+    pub dnf_condition: Option<DnfCondition>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataRole {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<MetadataRoleProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetadataRoleList {
+    pub values: Vec<MetadataRole>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
diff --git a/services/svc/purview/src/package_2021_07_01_preview/operations.rs b/services/svc/purview/src/package_2021_07_01_preview/operations.rs
new file mode 100644
index 0000000000..23544306f8
--- /dev/null
+++ b/services/svc/purview/src/package_2021_07_01_preview/operations.rs
@@ -0,0 +1,264 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod metadata_roles {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<MetadataRoleList, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/metadataRoles", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetadataRoleList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod metadata_policy {
+    use crate::models::*;
+    pub async fn list_all(
+        operation_config: &crate::OperationConfig,
+        collection_name: Option<&str>,
+    ) -> std::result::Result<MetadataPolicyList, list_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/metadataPolicies", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(collection_name) = collection_name {
+            url.query_pairs_mut().append_pair("collectionName", collection_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetadataPolicyList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, policy_id: &str) -> std::result::Result<MetadataPolicy, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/metadataPolicies/{}", operation_config.base_path(), policy_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetadataPolicy =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        policy_id: &str,
+        body: Option<&MetadataPolicy>,
+    ) -> std::result::Result<MetadataPolicy, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/metadataPolicies/{}", operation_config.base_path(), policy_id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = if let Some(body) = body {
+            azure_core::to_json(body).map_err(update::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetadataPolicy =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorResponseModel =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorResponseModel,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/quantum/Cargo.toml b/services/svc/quantum/Cargo.toml
new file mode 100644
index 0000000000..7805c22669
--- /dev/null
+++ b/services/svc/quantum/Cargo.toml
@@ -0,0 +1,24 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_quantum"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2019-11-04-preview"]
+"package-2019-11-04-preview" = []
+"package-2021-05-06-preview" = []
diff --git a/services/svc/quantum/src/lib.rs b/services/svc/quantum/src/lib.rs
new file mode 100644
index 0000000000..f30037289b
--- /dev/null
+++ b/services/svc/quantum/src/lib.rs
@@ -0,0 +1,65 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2019-11-04-preview")]
+mod package_2019_11_04_preview;
+#[cfg(feature = "package-2019-11-04-preview")]
+pub use package_2019_11_04_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-05-06-preview")]
+mod package_2021_05_06_preview;
+use azure_core::setters;
+#[cfg(feature = "package-2021-05-06-preview")]
+pub use package_2021_05_06_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/quantum/src/package_2019_11_04_preview/mod.rs b/services/svc/quantum/src/package_2019_11_04_preview/mod.rs
new file mode 100644
index 0000000000..ea414ae595
--- /dev/null
+++ b/services/svc/quantum/src/package_2019_11_04_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-11-04-preview";
diff --git a/services/svc/quantum/src/package_2019_11_04_preview/models.rs b/services/svc/quantum/src/package_2019_11_04_preview/models.rs
new file mode 100644
index 0000000000..d58a059ba1
--- /dev/null
+++ b/services/svc/quantum/src/package_2019_11_04_preview/models.rs
@@ -0,0 +1,166 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDetailsList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobDetails>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "containerUri")]
+    pub container_uri: String,
+    #[serde(rename = "inputDataUri", default, skip_serializing_if = "Option::is_none")]
+    pub input_data_uri: Option<String>,
+    #[serde(rename = "inputDataFormat")]
+    pub input_data_format: String,
+    #[serde(rename = "inputParams", default, skip_serializing_if = "Option::is_none")]
+    pub input_params: Option<serde_json::Value>,
+    #[serde(rename = "providerId")]
+    pub provider_id: String,
+    pub target: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+    #[serde(rename = "outputDataUri", default, skip_serializing_if = "Option::is_none")]
+    pub output_data_uri: Option<String>,
+    #[serde(rename = "outputDataFormat", default, skip_serializing_if = "Option::is_none")]
+    pub output_data_format: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<job_details::Status>,
+    #[serde(rename = "creationTime", default, skip_serializing_if = "Option::is_none")]
+    pub creation_time: Option<String>,
+    #[serde(rename = "beginExecutionTime", default, skip_serializing_if = "Option::is_none")]
+    pub begin_execution_time: Option<String>,
+    #[serde(rename = "endExecutionTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_execution_time: Option<String>,
+    #[serde(rename = "cancellationTime", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_time: Option<String>,
+    #[serde(rename = "errorData", default, skip_serializing_if = "Option::is_none")]
+    pub error_data: Option<ErrorData>,
+}
+pub mod job_details {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Waiting,
+        Executing,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobDetails {
+    #[serde(rename = "containerName")]
+    pub container_name: String,
+    #[serde(rename = "blobName", default, skip_serializing_if = "Option::is_none")]
+    pub blob_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SasUriResponse {
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProviderStatusList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ProviderStatus>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProviderStatus {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "currentAvailability", default, skip_serializing_if = "Option::is_none")]
+    pub current_availability: Option<provider_status::CurrentAvailability>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub targets: Vec<TargetStatus>,
+}
+pub mod provider_status {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentAvailability {
+        Available,
+        Degraded,
+        Unavailable,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TargetStatus {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "currentAvailability", default, skip_serializing_if = "Option::is_none")]
+    pub current_availability: Option<target_status::CurrentAvailability>,
+    #[serde(rename = "averageQueueTime", default, skip_serializing_if = "Option::is_none")]
+    pub average_queue_time: Option<i64>,
+    #[serde(rename = "statusPage", default, skip_serializing_if = "Option::is_none")]
+    pub status_page: Option<String>,
+}
+pub mod target_status {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentAvailability {
+        Available,
+        Degraded,
+        Unavailable,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuotaList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<Quota>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Quota {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dimension: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scope: Option<quota::Scope>,
+    #[serde(rename = "providerId", default, skip_serializing_if = "Option::is_none")]
+    pub provider_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub utilization: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub holds: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub period: Option<quota::Period>,
+}
+pub mod quota {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Scope {
+        Workspace,
+        Subscription,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Period {
+        None,
+        Monthly,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorData>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
diff --git a/services/svc/quantum/src/package_2019_11_04_preview/operations.rs b/services/svc/quantum/src/package_2019_11_04_preview/operations.rs
new file mode 100644
index 0000000000..a7b837d011
--- /dev/null
+++ b/services/svc/quantum/src/package_2019_11_04_preview/operations.rs
@@ -0,0 +1,515 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod jobs {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+    ) -> std::result::Result<JobDetailsList, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetailsList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        job_id: &str,
+    ) -> std::result::Result<JobDetails, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs/{}",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name,
+            job_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        job_id: &str,
+        job: &JobDetails,
+    ) -> std::result::Result<create::Response, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs/{}",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name,
+            job_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(job).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Created201(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(JobDetails),
+            Created201(JobDetails),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        job_id: &str,
+    ) -> std::result::Result<(), cancel::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs/{}",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name,
+            job_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| cancel::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod providers {
+    use crate::models::*;
+    pub async fn get_status(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+    ) -> std::result::Result<ProviderStatusList, get_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/providerStatus",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProviderStatusList =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_status::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod storage {
+    use crate::models::*;
+    pub async fn sas_uri(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        blob_details: &BlobDetails,
+    ) -> std::result::Result<SasUriResponse, sas_uri::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/storage/sasUri",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(sas_uri::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(sas_uri::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(blob_details).map_err(sas_uri::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(sas_uri::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(sas_uri::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SasUriResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| sas_uri::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| sas_uri::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(sas_uri::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod sas_uri {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod quotas {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+    ) -> std::result::Result<QuotaList, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/quotas",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QuotaList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/quantum/src/package_2021_05_06_preview/mod.rs b/services/svc/quantum/src/package_2021_05_06_preview/mod.rs
new file mode 100644
index 0000000000..1a5ad3740b
--- /dev/null
+++ b/services/svc/quantum/src/package_2021_05_06_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-05-06-preview";
diff --git a/services/svc/quantum/src/package_2021_05_06_preview/models.rs b/services/svc/quantum/src/package_2021_05_06_preview/models.rs
new file mode 100644
index 0000000000..1dbd39e202
--- /dev/null
+++ b/services/svc/quantum/src/package_2021_05_06_preview/models.rs
@@ -0,0 +1,196 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDetailsList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<JobDetails>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JobDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "containerUri")]
+    pub container_uri: String,
+    #[serde(rename = "inputDataUri", default, skip_serializing_if = "Option::is_none")]
+    pub input_data_uri: Option<String>,
+    #[serde(rename = "inputDataFormat")]
+    pub input_data_format: String,
+    #[serde(rename = "inputParams", default, skip_serializing_if = "Option::is_none")]
+    pub input_params: Option<serde_json::Value>,
+    #[serde(rename = "providerId")]
+    pub provider_id: String,
+    pub target: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+    #[serde(rename = "outputDataUri", default, skip_serializing_if = "Option::is_none")]
+    pub output_data_uri: Option<String>,
+    #[serde(rename = "outputDataFormat", default, skip_serializing_if = "Option::is_none")]
+    pub output_data_format: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<job_details::Status>,
+    #[serde(rename = "creationTime", default, skip_serializing_if = "Option::is_none")]
+    pub creation_time: Option<String>,
+    #[serde(rename = "beginExecutionTime", default, skip_serializing_if = "Option::is_none")]
+    pub begin_execution_time: Option<String>,
+    #[serde(rename = "endExecutionTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_execution_time: Option<String>,
+    #[serde(rename = "cancellationTime", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_time: Option<String>,
+    #[serde(rename = "errorData", default, skip_serializing_if = "Option::is_none")]
+    pub error_data: Option<ErrorData>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+}
+pub mod job_details {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Waiting,
+        Executing,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobDetails {
+    #[serde(rename = "containerName")]
+    pub container_name: String,
+    #[serde(rename = "blobName", default, skip_serializing_if = "Option::is_none")]
+    pub blob_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SasUriResponse {
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProviderStatusList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ProviderStatus>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProviderStatus {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "currentAvailability", default, skip_serializing_if = "Option::is_none")]
+    pub current_availability: Option<provider_status::CurrentAvailability>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub targets: Vec<TargetStatus>,
+}
+pub mod provider_status {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentAvailability {
+        Available,
+        Degraded,
+        Unavailable,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TargetStatus {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "currentAvailability", default, skip_serializing_if = "Option::is_none")]
+    pub current_availability: Option<target_status::CurrentAvailability>,
+    #[serde(rename = "averageQueueTime", default, skip_serializing_if = "Option::is_none")]
+    pub average_queue_time: Option<i64>,
+    #[serde(rename = "statusPage", default, skip_serializing_if = "Option::is_none")]
+    pub status_page: Option<String>,
+}
+pub mod target_status {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentAvailability {
+        Available,
+        Degraded,
+        Unavailable,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuotaList {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<Quota>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Quota {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dimension: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scope: Option<quota::Scope>,
+    #[serde(rename = "providerId", default, skip_serializing_if = "Option::is_none")]
+    pub provider_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub utilization: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub holds: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub period: Option<quota::Period>,
+}
+pub mod quota {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Scope {
+        Workspace,
+        Subscription,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Period {
+        None,
+        Monthly,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorData>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorData {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+pub type PatchRequest = Vec<JsonPatchDocument>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonPatchDocument {
+    pub op: json_patch_document::Op,
+    pub path: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub from: Option<String>,
+}
+pub mod json_patch_document {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Op {
+        #[serde(rename = "add")]
+        Add,
+        #[serde(rename = "remove")]
+        Remove,
+        #[serde(rename = "replace")]
+        Replace,
+        #[serde(rename = "move")]
+        Move,
+        #[serde(rename = "copy")]
+        Copy,
+        #[serde(rename = "test")]
+        Test,
+    }
+}
diff --git a/services/svc/quantum/src/package_2021_05_06_preview/operations.rs b/services/svc/quantum/src/package_2021_05_06_preview/operations.rs
new file mode 100644
index 0000000000..3e8dcb5e46
--- /dev/null
+++ b/services/svc/quantum/src/package_2021_05_06_preview/operations.rs
@@ -0,0 +1,593 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod jobs {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+    ) -> std::result::Result<JobDetailsList, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetailsList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        job_id: &str,
+    ) -> std::result::Result<JobDetails, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs/{}",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name,
+            job_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        job_id: &str,
+        job: &JobDetails,
+    ) -> std::result::Result<create::Response, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs/{}",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name,
+            job_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(job).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Created201(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(JobDetails),
+            Created201(JobDetails),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn patch(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        job_id: &str,
+        patch_job: &PatchRequest,
+    ) -> std::result::Result<patch::Response, patch::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs/{}",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name,
+            job_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(patch::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(patch::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(patch_job).map_err(patch::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(patch::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(patch::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: JobDetails =
+                    serde_json::from_slice(rsp_body).map_err(|source| patch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(patch::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::NO_CONTENT => Ok(patch::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| patch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(patch::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod patch {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(JobDetails),
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        job_id: &str,
+    ) -> std::result::Result<(), cancel::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/jobs/{}",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name,
+            job_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(cancel::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| cancel::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod providers {
+    use crate::models::*;
+    pub async fn get_status(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+    ) -> std::result::Result<ProviderStatusList, get_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/providerStatus",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ProviderStatusList =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_status::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod storage {
+    use crate::models::*;
+    pub async fn sas_uri(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+        blob_details: &BlobDetails,
+    ) -> std::result::Result<SasUriResponse, sas_uri::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/storage/sasUri",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(sas_uri::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(sas_uri::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(blob_details).map_err(sas_uri::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(sas_uri::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(sas_uri::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SasUriResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| sas_uri::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| sas_uri::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(sas_uri::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod sas_uri {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod quotas {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        subscription_id: &str,
+        resource_group_name: &str,
+        workspace_name: &str,
+    ) -> std::result::Result<QuotaList, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/v1.0/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Quantum/workspaces/{}/quotas",
+            operation_config.base_path(),
+            subscription_id,
+            resource_group_name,
+            workspace_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QuotaList =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: RestError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::RestError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/Cargo.toml b/services/svc/synapse/Cargo.toml
new file mode 100644
index 0000000000..706f969896
--- /dev/null
+++ b/services/svc/synapse/Cargo.toml
@@ -0,0 +1,38 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_synapse"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-artifacts-composite-v1"]
+"package-metadata-2021-07-01-preview" = []
+"package-artifacts-composite-v1" = []
+"package-artifacts-2021-06-01-preview" = []
+"package-vnet-2021-06-01-preview" = []
+"package-kql-script-2021-06-preview" = []
+"package-artifacts-2020-12-01" = []
+"package-monitoring-2020-12-01" = []
+"package-access-control-2020-12-01" = []
+"package-vnet-2020-12-01" = []
+"package-spark-2020-12-01" = []
+"package-spark-2019-11-01-preview" = []
+"package-artifacts-2019-06-01-preview" = []
+"package-access-control-2020-02-01-preview" = []
+"package-access-control-2020-08-01-preview" = []
+"package-vnet-2019-06-01-preview" = []
+"package-monitoring-2019-11-01-preview" = []
diff --git a/services/svc/synapse/src/lib.rs b/services/svc/synapse/src/lib.rs
new file mode 100644
index 0000000000..a2892ea3e2
--- /dev/null
+++ b/services/svc/synapse/src/lib.rs
@@ -0,0 +1,121 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-metadata-2021-07-01-preview")]
+mod package_metadata_2021_07_01_preview;
+#[cfg(feature = "package-metadata-2021-07-01-preview")]
+pub use package_metadata_2021_07_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-artifacts-composite-v1")]
+mod package_artifacts_composite_v1;
+#[cfg(feature = "package-artifacts-composite-v1")]
+pub use package_artifacts_composite_v1::{models, operations, API_VERSION};
+#[cfg(feature = "package-artifacts-2021-06-01-preview")]
+mod package_artifacts_2021_06_01_preview;
+#[cfg(feature = "package-artifacts-2021-06-01-preview")]
+pub use package_artifacts_2021_06_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-vnet-2021-06-01-preview")]
+mod package_vnet_2021_06_01_preview;
+#[cfg(feature = "package-vnet-2021-06-01-preview")]
+pub use package_vnet_2021_06_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-kql-script-2021-06-preview")]
+mod package_kql_script_2021_06_preview;
+#[cfg(feature = "package-kql-script-2021-06-preview")]
+pub use package_kql_script_2021_06_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-artifacts-2020-12-01")]
+mod package_artifacts_2020_12_01;
+#[cfg(feature = "package-artifacts-2020-12-01")]
+pub use package_artifacts_2020_12_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-monitoring-2020-12-01")]
+mod package_monitoring_2020_12_01;
+#[cfg(feature = "package-monitoring-2020-12-01")]
+pub use package_monitoring_2020_12_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-access-control-2020-12-01")]
+mod package_access_control_2020_12_01;
+#[cfg(feature = "package-access-control-2020-12-01")]
+pub use package_access_control_2020_12_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-vnet-2020-12-01")]
+mod package_vnet_2020_12_01;
+#[cfg(feature = "package-vnet-2020-12-01")]
+pub use package_vnet_2020_12_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-spark-2020-12-01")]
+mod package_spark_2020_12_01;
+#[cfg(feature = "package-spark-2020-12-01")]
+pub use package_spark_2020_12_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-spark-2019-11-01-preview")]
+mod package_spark_2019_11_01_preview;
+#[cfg(feature = "package-spark-2019-11-01-preview")]
+pub use package_spark_2019_11_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-artifacts-2019-06-01-preview")]
+mod package_artifacts_2019_06_01_preview;
+#[cfg(feature = "package-artifacts-2019-06-01-preview")]
+pub use package_artifacts_2019_06_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-access-control-2020-02-01-preview")]
+mod package_access_control_2020_02_01_preview;
+#[cfg(feature = "package-access-control-2020-02-01-preview")]
+pub use package_access_control_2020_02_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-access-control-2020-08-01-preview")]
+mod package_access_control_2020_08_01_preview;
+#[cfg(feature = "package-access-control-2020-08-01-preview")]
+pub use package_access_control_2020_08_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-vnet-2019-06-01-preview")]
+mod package_vnet_2019_06_01_preview;
+#[cfg(feature = "package-vnet-2019-06-01-preview")]
+pub use package_vnet_2019_06_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-monitoring-2019-11-01-preview")]
+mod package_monitoring_2019_11_01_preview;
+use azure_core::setters;
+#[cfg(feature = "package-monitoring-2019-11-01-preview")]
+pub use package_monitoring_2019_11_01_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/synapse/src/package_access_control_2020_02_01_preview/mod.rs b/services/svc/synapse/src/package_access_control_2020_02_01_preview/mod.rs
new file mode 100644
index 0000000000..7d0dd099e3
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_02_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-02-01-preview";
diff --git a/services/svc/synapse/src/package_access_control_2020_02_01_preview/models.rs b/services/svc/synapse/src/package_access_control_2020_02_01_preview/models.rs
new file mode 100644
index 0000000000..d91537e168
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_02_01_preview/models.rs
@@ -0,0 +1,57 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RolesListResponse {
+    pub value: Vec<SynapseRole>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseRole {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "isBuiltIn")]
+    pub is_built_in: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorDetail>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorDetail {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+}
+pub type RoleAssignmentDetailsList = Vec<RoleAssignmentDetails>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignmentOptions {
+    #[serde(rename = "roleId")]
+    pub role_id: String,
+    #[serde(rename = "principalId")]
+    pub principal_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignmentDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "roleId", default, skip_serializing_if = "Option::is_none")]
+    pub role_id: Option<String>,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_access_control_2020_02_01_preview/operations.rs b/services/svc/synapse/src/package_access_control_2020_02_01_preview/operations.rs
new file mode 100644
index 0000000000..31494c15b8
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_02_01_preview/operations.rs
@@ -0,0 +1,481 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub async fn get_role_definitions(
+    operation_config: &crate::OperationConfig,
+) -> std::result::Result<RolesListResponse, get_role_definitions::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/rbac/roles", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_role_definitions::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_role_definitions::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_role_definitions::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_role_definitions::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: RolesListResponse = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_role_definitions::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_role_definitions::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_role_definitions::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_role_definitions {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::ErrorContract,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_role_definition_by_id(
+    operation_config: &crate::OperationConfig,
+    role_id: &str,
+) -> std::result::Result<SynapseRole, get_role_definition_by_id::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/rbac/roles/{}", operation_config.base_path(), role_id);
+    let mut url = url::Url::parse(url_str).map_err(get_role_definition_by_id::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_role_definition_by_id::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(get_role_definition_by_id::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_role_definition_by_id::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: SynapseRole = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_role_definition_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_role_definition_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_role_definition_by_id::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_role_definition_by_id {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::ErrorContract,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_role_assignments(
+    operation_config: &crate::OperationConfig,
+    role_id: Option<&str>,
+    principal_id: Option<&str>,
+    x_ms_continuation: Option<&str>,
+) -> std::result::Result<RoleAssignmentDetailsList, get_role_assignments::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/rbac/roleAssignments", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_role_assignments::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_role_assignments::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    if let Some(role_id) = role_id {
+        url.query_pairs_mut().append_pair("roleId", role_id);
+    }
+    if let Some(principal_id) = principal_id {
+        url.query_pairs_mut().append_pair("principalId", principal_id);
+    }
+    if let Some(x_ms_continuation) = x_ms_continuation {
+        req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+    }
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder.body(req_body).map_err(get_role_assignments::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_role_assignments::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: RoleAssignmentDetailsList = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_role_assignments::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_role_assignments {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::ErrorContract,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn create_role_assignment(
+    operation_config: &crate::OperationConfig,
+    create_role_assignment_options: &RoleAssignmentOptions,
+) -> std::result::Result<RoleAssignmentDetails, create_role_assignment::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/rbac/roleAssignments", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(create_role_assignment::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::POST);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(create_role_assignment::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    let req_body = azure_core::to_json(create_role_assignment_options).map_err(create_role_assignment::Error::SerializeError)?;
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(create_role_assignment::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(create_role_assignment::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: RoleAssignmentDetails = serde_json::from_slice(rsp_body)
+                .map_err(|source| create_role_assignment::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                .map_err(|source| create_role_assignment::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(create_role_assignment::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod create_role_assignment {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::ErrorContract,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_role_assignment_by_id(
+    operation_config: &crate::OperationConfig,
+    role_assignment_id: &str,
+) -> std::result::Result<RoleAssignmentDetails, get_role_assignment_by_id::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/rbac/roleAssignments/{}", operation_config.base_path(), role_assignment_id);
+    let mut url = url::Url::parse(url_str).map_err(get_role_assignment_by_id::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::GET);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_role_assignment_by_id::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(get_role_assignment_by_id::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_role_assignment_by_id::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: RoleAssignmentDetails = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_role_assignment_by_id::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_role_assignment_by_id {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::ErrorContract,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn delete_role_assignment_by_id(
+    operation_config: &crate::OperationConfig,
+    role_assignment_id: &str,
+) -> std::result::Result<delete_role_assignment_by_id::Response, delete_role_assignment_by_id::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/rbac/roleAssignments/{}", operation_config.base_path(), role_assignment_id);
+    let mut url = url::Url::parse(url_str).map_err(delete_role_assignment_by_id::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::DELETE);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(delete_role_assignment_by_id::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(delete_role_assignment_by_id::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(delete_role_assignment_by_id::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => Ok(delete_role_assignment_by_id::Response::Ok200),
+        http::StatusCode::NO_CONTENT => Ok(delete_role_assignment_by_id::Response::NoContent204),
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                .map_err(|source| delete_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(delete_role_assignment_by_id::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod delete_role_assignment_by_id {
+    use crate::{models, models::*};
+    #[derive(Debug)]
+    pub enum Response {
+        Ok200,
+        NoContent204,
+    }
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::ErrorContract,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
+pub async fn get_caller_role_assignments(
+    operation_config: &crate::OperationConfig,
+) -> std::result::Result<Vec<String>, get_caller_role_assignments::Error> {
+    let http_client = operation_config.http_client();
+    let url_str = &format!("{}/rbac/getMyAssignedRoles", operation_config.base_path(),);
+    let mut url = url::Url::parse(url_str).map_err(get_caller_role_assignments::Error::ParseUrlError)?;
+    let mut req_builder = http::request::Builder::new();
+    req_builder = req_builder.method(http::Method::POST);
+    if let Some(token_credential) = operation_config.token_credential() {
+        let token_response = token_credential
+            .get_token(operation_config.token_credential_resource())
+            .await
+            .map_err(get_caller_role_assignments::Error::GetTokenError)?;
+        req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+    }
+    url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+    let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+    req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+    req_builder = req_builder.uri(url.as_str());
+    let req = req_builder
+        .body(req_body)
+        .map_err(get_caller_role_assignments::Error::BuildRequestError)?;
+    let rsp = http_client
+        .execute_request(req)
+        .await
+        .map_err(get_caller_role_assignments::Error::ExecuteRequestError)?;
+    match rsp.status() {
+        http::StatusCode::OK => {
+            let rsp_body = rsp.body();
+            let rsp_value: Vec<String> = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_caller_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+            Ok(rsp_value)
+        }
+        status_code => {
+            let rsp_body = rsp.body();
+            let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                .map_err(|source| get_caller_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+            Err(get_caller_role_assignments::Error::DefaultResponse {
+                status_code,
+                value: rsp_value,
+            })
+        }
+    }
+}
+pub mod get_caller_role_assignments {
+    use crate::{models, models::*};
+    #[derive(Debug, thiserror :: Error)]
+    pub enum Error {
+        #[error("HTTP status code {}", status_code)]
+        DefaultResponse {
+            status_code: http::StatusCode,
+            value: models::ErrorContract,
+        },
+        #[error("Failed to parse request URL: {0}")]
+        ParseUrlError(url::ParseError),
+        #[error("Failed to build request: {0}")]
+        BuildRequestError(http::Error),
+        #[error("Failed to execute request: {0}")]
+        ExecuteRequestError(azure_core::HttpError),
+        #[error("Failed to serialize request body: {0}")]
+        SerializeError(serde_json::Error),
+        #[error("Failed to deserialize response: {0}, body: {1:?}")]
+        DeserializeError(serde_json::Error, bytes::Bytes),
+        #[error("Failed to get access token: {0}")]
+        GetTokenError(azure_core::Error),
+    }
+}
diff --git a/services/svc/synapse/src/package_access_control_2020_08_01_preview/mod.rs b/services/svc/synapse/src/package_access_control_2020_08_01_preview/mod.rs
new file mode 100644
index 0000000000..18d2b5f1f0
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_08_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-08-01-preview";
diff --git a/services/svc/synapse/src/package_access_control_2020_08_01_preview/models.rs b/services/svc/synapse/src/package_access_control_2020_08_01_preview/models.rs
new file mode 100644
index 0000000000..da92b91f84
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_08_01_preview/models.rs
@@ -0,0 +1,117 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorDetail>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorDetail {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CheckPrincipalAccessRequest {
+    pub subject: SubjectInfo,
+    pub actions: Vec<RequiredAction>,
+    pub scope: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RequiredAction {
+    pub id: String,
+    #[serde(rename = "isDataAction")]
+    pub is_data_action: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CheckPrincipalAccessResponse {
+    #[serde(rename = "AccessDecisions", default, skip_serializing_if = "Vec::is_empty")]
+    pub access_decisions: Vec<CheckAccessDecision>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubjectInfo {
+    #[serde(rename = "principalId")]
+    pub principal_id: String,
+    #[serde(rename = "groupIds", default, skip_serializing_if = "Vec::is_empty")]
+    pub group_ids: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CheckAccessDecision {
+    #[serde(rename = "accessDecision", default, skip_serializing_if = "Option::is_none")]
+    pub access_decision: Option<String>,
+    #[serde(rename = "actionId", default, skip_serializing_if = "Option::is_none")]
+    pub action_id: Option<String>,
+    #[serde(rename = "roleAssignment", default, skip_serializing_if = "Option::is_none")]
+    pub role_assignment: Option<RoleAssignmentDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignmentDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "roleDefinitionId", default, skip_serializing_if = "Option::is_none")]
+    pub role_definition_id: Option<String>,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scope: Option<String>,
+    #[serde(rename = "principalType", default, skip_serializing_if = "Option::is_none")]
+    pub principal_type: Option<String>,
+}
+pub type RoleDefinitionsListResponse = Vec<SynapseRoleDefinition>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseRoleDefinition {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "isBuiltIn", default, skip_serializing_if = "Option::is_none")]
+    pub is_built_in: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub permissions: Vec<SynapseRbacPermission>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub scopes: Vec<String>,
+    #[serde(rename = "availabilityStatus", default, skip_serializing_if = "Option::is_none")]
+    pub availability_status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseRbacPermission {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub actions: Vec<String>,
+    #[serde(rename = "notActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub not_actions: Vec<String>,
+    #[serde(rename = "dataActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_actions: Vec<String>,
+    #[serde(rename = "notDataActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub not_data_actions: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignmentRequest {
+    #[serde(rename = "roleId")]
+    pub role_id: String,
+    #[serde(rename = "principalId")]
+    pub principal_id: String,
+    pub scope: String,
+    #[serde(rename = "principalType", default, skip_serializing_if = "Option::is_none")]
+    pub principal_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignmentDetailsList {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<RoleAssignmentDetails>,
+}
diff --git a/services/svc/synapse/src/package_access_control_2020_08_01_preview/operations.rs b/services/svc/synapse/src/package_access_control_2020_08_01_preview/operations.rs
new file mode 100644
index 0000000000..235deee793
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_08_01_preview/operations.rs
@@ -0,0 +1,570 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod role_assignments {
+    use crate::models::*;
+    pub async fn check_principal_access(
+        operation_config: &crate::OperationConfig,
+        request: &CheckPrincipalAccessRequest,
+    ) -> std::result::Result<CheckPrincipalAccessResponse, check_principal_access::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/checkAccessSynapseRbac", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(check_principal_access::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(check_principal_access::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(check_principal_access::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(check_principal_access::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(check_principal_access::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: CheckPrincipalAccessResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| check_principal_access::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| check_principal_access::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(check_principal_access::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod check_principal_access {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_role_assignments(
+        operation_config: &crate::OperationConfig,
+        role_id: Option<&str>,
+        principal_id: Option<&str>,
+        scope: Option<&str>,
+        x_ms_continuation: Option<&str>,
+    ) -> std::result::Result<RoleAssignmentDetailsList, list_role_assignments::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleAssignments", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_role_assignments::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_role_assignments::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(role_id) = role_id {
+            url.query_pairs_mut().append_pair("roleId", role_id);
+        }
+        if let Some(principal_id) = principal_id {
+            url.query_pairs_mut().append_pair("principalId", principal_id);
+        }
+        if let Some(scope) = scope {
+            url.query_pairs_mut().append_pair("scope", scope);
+        }
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_role_assignments::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_role_assignments::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleAssignmentDetailsList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_role_assignments::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_role_assignments {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_role_assignment_by_id(
+        operation_config: &crate::OperationConfig,
+        role_assignment_id: &str,
+    ) -> std::result::Result<RoleAssignmentDetails, get_role_assignment_by_id::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleAssignments/{}", operation_config.base_path(), role_assignment_id);
+        let mut url = url::Url::parse(url_str).map_err(get_role_assignment_by_id::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_role_assignment_by_id::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_role_assignment_by_id::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_role_assignment_by_id::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleAssignmentDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_role_assignment_by_id::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_role_assignment_by_id {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_role_assignment(
+        operation_config: &crate::OperationConfig,
+        request: &RoleAssignmentRequest,
+        role_assignment_id: &str,
+    ) -> std::result::Result<RoleAssignmentDetails, create_role_assignment::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleAssignments/{}", operation_config.base_path(), role_assignment_id);
+        let mut url = url::Url::parse(url_str).map_err(create_role_assignment::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_role_assignment::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(create_role_assignment::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_role_assignment::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_role_assignment::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleAssignmentDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_role_assignment::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_role_assignment::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_role_assignment::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_role_assignment {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_role_assignment_by_id(
+        operation_config: &crate::OperationConfig,
+        role_assignment_id: &str,
+        scope: Option<&str>,
+    ) -> std::result::Result<delete_role_assignment_by_id::Response, delete_role_assignment_by_id::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleAssignments/{}", operation_config.base_path(), role_assignment_id);
+        let mut url = url::Url::parse(url_str).map_err(delete_role_assignment_by_id::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_role_assignment_by_id::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(scope) = scope {
+            url.query_pairs_mut().append_pair("scope", scope);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_role_assignment_by_id::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_role_assignment_by_id::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_role_assignment_by_id::Response::Ok200),
+            http::StatusCode::NO_CONTENT => Ok(delete_role_assignment_by_id::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_role_assignment_by_id::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_role_assignment_by_id {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod role_definitions {
+    use crate::models::*;
+    pub async fn list_role_definitions(
+        operation_config: &crate::OperationConfig,
+        is_built_in: Option<bool>,
+        scope: Option<&str>,
+    ) -> std::result::Result<RoleDefinitionsListResponse, list_role_definitions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleDefinitions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_role_definitions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_role_definitions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(is_built_in) = is_built_in {
+            url.query_pairs_mut().append_pair("isBuiltIn", is_built_in.to_string().as_str());
+        }
+        if let Some(scope) = scope {
+            url.query_pairs_mut().append_pair("scope", scope);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_role_definitions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_role_definitions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleDefinitionsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_role_definitions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_role_definitions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_role_definitions::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_role_definitions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_role_definition_by_id(
+        operation_config: &crate::OperationConfig,
+        role_definition_id: &str,
+    ) -> std::result::Result<SynapseRoleDefinition, get_role_definition_by_id::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleDefinitions/{}", operation_config.base_path(), role_definition_id);
+        let mut url = url::Url::parse(url_str).map_err(get_role_definition_by_id::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_role_definition_by_id::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_role_definition_by_id::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_role_definition_by_id::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SynapseRoleDefinition = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_role_definition_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_role_definition_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_role_definition_by_id::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_role_definition_by_id {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_scopes(operation_config: &crate::OperationConfig) -> std::result::Result<Vec<String>, list_scopes::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/rbacScopes", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_scopes::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_scopes::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_scopes::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_scopes::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Vec<String> =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_scopes::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_scopes::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_scopes::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_scopes {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_access_control_2020_12_01/mod.rs b/services/svc/synapse/src/package_access_control_2020_12_01/mod.rs
new file mode 100644
index 0000000000..295814b1a2
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_12_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-12-01";
diff --git a/services/svc/synapse/src/package_access_control_2020_12_01/models.rs b/services/svc/synapse/src/package_access_control_2020_12_01/models.rs
new file mode 100644
index 0000000000..1c8d4a1ea8
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_12_01/models.rs
@@ -0,0 +1,121 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CheckPrincipalAccessRequest {
+    pub subject: SubjectInfo,
+    pub actions: Vec<RequiredAction>,
+    pub scope: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RequiredAction {
+    pub id: String,
+    #[serde(rename = "isDataAction")]
+    pub is_data_action: bool,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CheckPrincipalAccessResponse {
+    #[serde(rename = "accessDecisions", default, skip_serializing_if = "Vec::is_empty")]
+    pub access_decisions: Vec<CheckAccessDecision>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubjectInfo {
+    #[serde(rename = "principalId")]
+    pub principal_id: String,
+    #[serde(rename = "groupIds", default, skip_serializing_if = "Vec::is_empty")]
+    pub group_ids: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CheckAccessDecision {
+    #[serde(rename = "accessDecision", default, skip_serializing_if = "Option::is_none")]
+    pub access_decision: Option<String>,
+    #[serde(rename = "actionId", default, skip_serializing_if = "Option::is_none")]
+    pub action_id: Option<String>,
+    #[serde(rename = "roleAssignment", default, skip_serializing_if = "Option::is_none")]
+    pub role_assignment: Option<RoleAssignmentDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignmentDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "roleDefinitionId", default, skip_serializing_if = "Option::is_none")]
+    pub role_definition_id: Option<String>,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scope: Option<String>,
+    #[serde(rename = "principalType", default, skip_serializing_if = "Option::is_none")]
+    pub principal_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignmentRequest {
+    #[serde(rename = "roleId")]
+    pub role_id: String,
+    #[serde(rename = "principalId")]
+    pub principal_id: String,
+    pub scope: String,
+    #[serde(rename = "principalType", default, skip_serializing_if = "Option::is_none")]
+    pub principal_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RoleAssignmentDetailsList {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<RoleAssignmentDetails>,
+}
+pub type RoleDefinitionsListResponse = Vec<SynapseRoleDefinition>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseRoleDefinition {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "isBuiltIn", default, skip_serializing_if = "Option::is_none")]
+    pub is_built_in: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub permissions: Vec<SynapseRbacPermission>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub scopes: Vec<String>,
+    #[serde(rename = "availabilityStatus", default, skip_serializing_if = "Option::is_none")]
+    pub availability_status: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseRbacPermission {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub actions: Vec<String>,
+    #[serde(rename = "notActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub not_actions: Vec<String>,
+    #[serde(rename = "dataActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub data_actions: Vec<String>,
+    #[serde(rename = "notDataActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub not_data_actions: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorResponse>,
+    #[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_info: Vec<ErrorAdditionalInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorAdditionalInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<serde_json::Value>,
+}
diff --git a/services/svc/synapse/src/package_access_control_2020_12_01/operations.rs b/services/svc/synapse/src/package_access_control_2020_12_01/operations.rs
new file mode 100644
index 0000000000..235deee793
--- /dev/null
+++ b/services/svc/synapse/src/package_access_control_2020_12_01/operations.rs
@@ -0,0 +1,570 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod role_assignments {
+    use crate::models::*;
+    pub async fn check_principal_access(
+        operation_config: &crate::OperationConfig,
+        request: &CheckPrincipalAccessRequest,
+    ) -> std::result::Result<CheckPrincipalAccessResponse, check_principal_access::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/checkAccessSynapseRbac", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(check_principal_access::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(check_principal_access::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(check_principal_access::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(check_principal_access::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(check_principal_access::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: CheckPrincipalAccessResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| check_principal_access::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| check_principal_access::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(check_principal_access::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod check_principal_access {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_role_assignments(
+        operation_config: &crate::OperationConfig,
+        role_id: Option<&str>,
+        principal_id: Option<&str>,
+        scope: Option<&str>,
+        x_ms_continuation: Option<&str>,
+    ) -> std::result::Result<RoleAssignmentDetailsList, list_role_assignments::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleAssignments", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_role_assignments::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_role_assignments::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(role_id) = role_id {
+            url.query_pairs_mut().append_pair("roleId", role_id);
+        }
+        if let Some(principal_id) = principal_id {
+            url.query_pairs_mut().append_pair("principalId", principal_id);
+        }
+        if let Some(scope) = scope {
+            url.query_pairs_mut().append_pair("scope", scope);
+        }
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_role_assignments::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_role_assignments::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleAssignmentDetailsList = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_role_assignments::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_role_assignments::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_role_assignments {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_role_assignment_by_id(
+        operation_config: &crate::OperationConfig,
+        role_assignment_id: &str,
+    ) -> std::result::Result<RoleAssignmentDetails, get_role_assignment_by_id::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleAssignments/{}", operation_config.base_path(), role_assignment_id);
+        let mut url = url::Url::parse(url_str).map_err(get_role_assignment_by_id::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_role_assignment_by_id::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_role_assignment_by_id::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_role_assignment_by_id::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleAssignmentDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_role_assignment_by_id::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_role_assignment_by_id {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_role_assignment(
+        operation_config: &crate::OperationConfig,
+        request: &RoleAssignmentRequest,
+        role_assignment_id: &str,
+    ) -> std::result::Result<RoleAssignmentDetails, create_role_assignment::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleAssignments/{}", operation_config.base_path(), role_assignment_id);
+        let mut url = url::Url::parse(url_str).map_err(create_role_assignment::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_role_assignment::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(create_role_assignment::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_role_assignment::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_role_assignment::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleAssignmentDetails = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_role_assignment::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_role_assignment::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_role_assignment::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_role_assignment {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_role_assignment_by_id(
+        operation_config: &crate::OperationConfig,
+        role_assignment_id: &str,
+        scope: Option<&str>,
+    ) -> std::result::Result<delete_role_assignment_by_id::Response, delete_role_assignment_by_id::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleAssignments/{}", operation_config.base_path(), role_assignment_id);
+        let mut url = url::Url::parse(url_str).map_err(delete_role_assignment_by_id::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_role_assignment_by_id::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(scope) = scope {
+            url.query_pairs_mut().append_pair("scope", scope);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_role_assignment_by_id::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_role_assignment_by_id::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_role_assignment_by_id::Response::Ok200),
+            http::StatusCode::NO_CONTENT => Ok(delete_role_assignment_by_id::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_role_assignment_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_role_assignment_by_id::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_role_assignment_by_id {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod role_definitions {
+    use crate::models::*;
+    pub async fn list_role_definitions(
+        operation_config: &crate::OperationConfig,
+        is_built_in: Option<bool>,
+        scope: Option<&str>,
+    ) -> std::result::Result<RoleDefinitionsListResponse, list_role_definitions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleDefinitions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_role_definitions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_role_definitions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(is_built_in) = is_built_in {
+            url.query_pairs_mut().append_pair("isBuiltIn", is_built_in.to_string().as_str());
+        }
+        if let Some(scope) = scope {
+            url.query_pairs_mut().append_pair("scope", scope);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(list_role_definitions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_role_definitions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: RoleDefinitionsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_role_definitions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| list_role_definitions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_role_definitions::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_role_definitions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_role_definition_by_id(
+        operation_config: &crate::OperationConfig,
+        role_definition_id: &str,
+    ) -> std::result::Result<SynapseRoleDefinition, get_role_definition_by_id::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/roleDefinitions/{}", operation_config.base_path(), role_definition_id);
+        let mut url = url::Url::parse(url_str).map_err(get_role_definition_by_id::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_role_definition_by_id::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_role_definition_by_id::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_role_definition_by_id::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SynapseRoleDefinition = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_role_definition_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_role_definition_by_id::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_role_definition_by_id::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_role_definition_by_id {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list_scopes(operation_config: &crate::OperationConfig) -> std::result::Result<Vec<String>, list_scopes::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/rbacScopes", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list_scopes::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list_scopes::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list_scopes::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(list_scopes::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Vec<String> =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_scopes::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list_scopes::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list_scopes::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list_scopes {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_artifacts_2019_06_01_preview/mod.rs b/services/svc/synapse/src/package_artifacts_2019_06_01_preview/mod.rs
new file mode 100644
index 0000000000..3a33dc519c
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2019_06_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-06-01-preview";
diff --git a/services/svc/synapse/src/package_artifacts_2019_06_01_preview/models.rs b/services/svc/synapse/src/package_artifacts_2019_06_01_preview/models.rs
new file mode 100644
index 0000000000..5f2cfe8760
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2019_06_01_preview/models.rs
@@ -0,0 +1,9324 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubResource {
+    #[serde(flatten)]
+    pub azure_entity_resource: AzureEntityResource,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubResourceDebugResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Expression {
+    #[serde(rename = "type")]
+    pub type_: expression::Type,
+    pub value: String,
+}
+pub mod expression {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Expression,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecureString {
+    #[serde(flatten)]
+    pub secret_base: SecretBase,
+    pub value: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultSecretReference {
+    #[serde(flatten)]
+    pub secret_base: SecretBase,
+    pub store: LinkedServiceReference,
+    #[serde(rename = "secretName")]
+    pub secret_name: serde_json::Value,
+    #[serde(rename = "secretVersion", default, skip_serializing_if = "Option::is_none")]
+    pub secret_version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecretBase {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeReference {
+    #[serde(rename = "type")]
+    pub type_: integration_runtime_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod integration_runtime_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        IntegrationRuntimeReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceListResponse {
+    pub value: Vec<LinkedServiceResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetListResponse {
+    pub value: Vec<DatasetResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineListResponse {
+    pub value: Vec<PipelineResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerListResponse {
+    pub value: Vec<TriggerResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowListResponse {
+    pub value: Vec<DataFlowResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateDataFlowDebugSessionRequest {
+    #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+    pub compute_type: Option<String>,
+    #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+    pub core_count: Option<i64>,
+    #[serde(rename = "timeToLive", default, skip_serializing_if = "Option::is_none")]
+    pub time_to_live: Option<i64>,
+    #[serde(rename = "integrationRuntime", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime: Option<IntegrationRuntimeDebugResource>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: IntegrationRuntime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateDataFlowDebugSessionResponse {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StartDataFlowDebugSessionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlow", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow: Option<DataFlowResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetResource>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<serde_json::Value>,
+    #[serde(rename = "debugSettings", default, skip_serializing_if = "Option::is_none")]
+    pub debug_settings: Option<serde_json::Value>,
+    #[serde(rename = "incrementalDebug", default, skip_serializing_if = "Option::is_none")]
+    pub incremental_debug: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StartDataFlowDebugSessionResponse {
+    #[serde(rename = "jobVersion", default, skip_serializing_if = "Option::is_none")]
+    pub job_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteDataFlowDebugSessionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugPreviewDataRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugStatisticsRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EvaluateDataFlowExpressionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expression: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub command: Option<data_flow_debug_command_request::Command>,
+    #[serde(rename = "commandPayload", default, skip_serializing_if = "Option::is_none")]
+    pub command_payload: Option<DataFlowDebugCommandPayload>,
+}
+pub mod data_flow_debug_command_request {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Command {
+        #[serde(rename = "executePreviewQuery")]
+        ExecutePreviewQuery,
+        #[serde(rename = "executeStatisticsQuery")]
+        ExecuteStatisticsQuery,
+        #[serde(rename = "executeExpressionQuery")]
+        ExecuteExpressionQuery,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandPayload {
+    #[serde(rename = "streamName")]
+    pub stream_name: String,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expression: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugQueryResponse {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugResultResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryDataFlowDebugSessionsResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<DataFlowDebugSessionInfo>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugSessionInfo {
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+    pub compute_type: Option<String>,
+    #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+    pub core_count: Option<i64>,
+    #[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub node_count: Option<i64>,
+    #[serde(rename = "integrationRuntimeName", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime_name: Option<String>,
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "timeToLiveInMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub time_to_live_in_minutes: Option<i64>,
+    #[serde(rename = "lastActivityTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_activity_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateRunResponse {
+    #[serde(rename = "runId")]
+    pub run_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudError {
+    pub error: CloudErrorBody,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudErrorBody {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<CloudError>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerDependencyProvisioningStatus {
+    #[serde(rename = "triggerName")]
+    pub trigger_name: String,
+    #[serde(rename = "provisioningStatus")]
+    pub provisioning_status: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VariableDefinitionSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VariableSpecification {
+    #[serde(rename = "type")]
+    pub type_: variable_specification::Type,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+pub mod variable_specification {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        String,
+        Bool,
+        Boolean,
+        Array,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterDefinitionSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterSpecification {
+    #[serde(rename = "type")]
+    pub type_: parameter_specification::Type,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+pub mod parameter_specification {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Object,
+        String,
+        Int,
+        Float,
+        Bool,
+        Array,
+        SecureString,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterValueSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Pipeline,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineReference {
+    #[serde(rename = "type")]
+    pub type_: pipeline_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+pub mod pipeline_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        PipelineReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerPipelineReference {
+    #[serde(rename = "pipelineReference", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_reference: Option<PipelineReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Trigger,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerSubscriptionOperationStatus {
+    #[serde(rename = "triggerName", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<trigger_subscription_operation_status::Status>,
+}
+pub mod trigger_subscription_operation_status {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Enabled,
+        Provisioning,
+        Deprovisioning,
+        Disabled,
+        Unknown,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceUpdateParameters {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<WorkspaceIdentity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceIdentity {
+    #[serde(rename = "type")]
+    pub type_: workspace_identity::Type,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
+pub mod workspace_identity {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SystemAssigned,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetReference {
+    #[serde(rename = "type")]
+    pub type_: dataset_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod dataset_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        DatasetReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceReference {
+    #[serde(rename = "type")]
+    pub type_: linked_service_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod linked_service_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        LinkedServiceReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: LinkedService,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: LinkedService,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptsListResponse {
+    pub value: Vec<SqlScriptResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    pub properties: SqlScript,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinitionsListResponse {
+    pub value: Vec<SparkJobDefinitionResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinitionResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: SparkJobDefinition,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookListResponse {
+    pub value: Vec<NotebookResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    pub properties: Notebook,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: DataFlow,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowReference {
+    #[serde(rename = "type")]
+    pub type_: data_flow_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(rename = "datasetParameters", default, skip_serializing_if = "Option::is_none")]
+    pub dataset_parameters: Option<serde_json::Value>,
+}
+pub mod data_flow_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        DataFlowReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowStagingInfo {
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugPackage {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlow", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow: Option<DataFlowDebugResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetDebugResource>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceDebugResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<DataFlowStagingInfo>,
+    #[serde(rename = "debugSettings", default, skip_serializing_if = "Option::is_none")]
+    pub debug_settings: Option<data_flow_debug_package::DebugSettings>,
+}
+pub mod data_flow_debug_package {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct DebugSettings {
+        #[serde(rename = "sourceSettings", default, skip_serializing_if = "Vec::is_empty")]
+        pub source_settings: Vec<DataFlowSourceSetting>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub parameters: Option<ParameterValueSpecification>,
+        #[serde(rename = "datasetParameters", default, skip_serializing_if = "Option::is_none")]
+        pub dataset_parameters: Option<serde_json::Value>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSourceSetting {
+    #[serde(rename = "sourceName", default, skip_serializing_if = "Option::is_none")]
+    pub source_name: Option<String>,
+    #[serde(rename = "rowLimit", default, skip_serializing_if = "Option::is_none")]
+    pub row_limit: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: DataFlow,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AddDataFlowToDebugSessionResponse {
+    #[serde(rename = "jobVersion", default, skip_serializing_if = "Option::is_none")]
+    pub job_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunFilterParameters {
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+    #[serde(rename = "lastUpdatedAfter")]
+    pub last_updated_after: String,
+    #[serde(rename = "lastUpdatedBefore")]
+    pub last_updated_before: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub filters: Vec<RunQueryFilter>,
+    #[serde(rename = "orderBy", default, skip_serializing_if = "Vec::is_empty")]
+    pub order_by: Vec<RunQueryOrderBy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunQueryFilter {
+    pub operand: run_query_filter::Operand,
+    pub operator: run_query_filter::Operator,
+    pub values: Vec<String>,
+}
+pub mod run_query_filter {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operand {
+        PipelineName,
+        Status,
+        RunStart,
+        RunEnd,
+        ActivityName,
+        ActivityRunStart,
+        ActivityRunEnd,
+        ActivityType,
+        TriggerName,
+        TriggerRunTimestamp,
+        RunGroupId,
+        LatestOnly,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operator {
+        Equals,
+        NotEquals,
+        In,
+        NotIn,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunQueryOrderBy {
+    #[serde(rename = "orderBy")]
+    pub order_by: run_query_order_by::OrderBy,
+    pub order: run_query_order_by::Order,
+}
+pub mod run_query_order_by {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OrderBy {
+        RunStart,
+        RunEnd,
+        PipelineName,
+        Status,
+        ActivityName,
+        ActivityRunStart,
+        ActivityRunEnd,
+        TriggerName,
+        TriggerRunTimestamp,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Order {
+        #[serde(rename = "ASC")]
+        Asc,
+        #[serde(rename = "DESC")]
+        Desc,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRunsQueryResponse {
+    pub value: Vec<PipelineRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRun {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "runGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub run_group_id: Option<String>,
+    #[serde(rename = "isLatest", default, skip_serializing_if = "Option::is_none")]
+    pub is_latest: Option<bool>,
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<serde_json::Value>,
+    #[serde(rename = "invokedBy", default, skip_serializing_if = "Option::is_none")]
+    pub invoked_by: Option<PipelineRunInvokedBy>,
+    #[serde(rename = "lastUpdated", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated: Option<String>,
+    #[serde(rename = "runStart", default, skip_serializing_if = "Option::is_none")]
+    pub run_start: Option<String>,
+    #[serde(rename = "runEnd", default, skip_serializing_if = "Option::is_none")]
+    pub run_end: Option<String>,
+    #[serde(rename = "durationInMs", default, skip_serializing_if = "Option::is_none")]
+    pub duration_in_ms: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRunInvokedBy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "invokedByType", default, skip_serializing_if = "Option::is_none")]
+    pub invoked_by_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityRunsQueryResponse {
+    pub value: Vec<ActivityRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityRun {
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(rename = "pipelineRunId", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_run_id: Option<String>,
+    #[serde(rename = "activityName", default, skip_serializing_if = "Option::is_none")]
+    pub activity_name: Option<String>,
+    #[serde(rename = "activityType", default, skip_serializing_if = "Option::is_none")]
+    pub activity_type: Option<String>,
+    #[serde(rename = "activityRunId", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_id: Option<String>,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "activityRunStart", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_start: Option<String>,
+    #[serde(rename = "activityRunEnd", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_end: Option<String>,
+    #[serde(rename = "durationInMs", default, skip_serializing_if = "Option::is_none")]
+    pub duration_in_ms: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub input: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRunsQueryResponse {
+    pub value: Vec<TriggerRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRun {
+    #[serde(rename = "triggerRunId", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_run_id: Option<String>,
+    #[serde(rename = "triggerName", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_name: Option<String>,
+    #[serde(rename = "triggerType", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_type: Option<String>,
+    #[serde(rename = "triggerRunTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_run_timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<trigger_run::Status>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(rename = "triggeredPipelines", default, skip_serializing_if = "Option::is_none")]
+    pub triggered_pipelines: Option<serde_json::Value>,
+}
+pub mod trigger_run {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Succeeded,
+        Failed,
+        Inprogress,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTumblingWindowTriggerActionParameters {
+    #[serde(rename = "startTime")]
+    pub start_time: String,
+    #[serde(rename = "endTime")]
+    pub end_time: String,
+    #[serde(rename = "maxConcurrency")]
+    pub max_concurrency: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTriggerListResponse {
+    pub value: Vec<RerunTriggerResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTriggerResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: RerunTumblingWindowTrigger,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetSsisObjectMetadataRequest {
+    #[serde(rename = "metadataPath", default, skip_serializing_if = "Option::is_none")]
+    pub metadata_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisObjectMetadataStatusResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExposureControlRequest {
+    #[serde(rename = "featureName", default, skip_serializing_if = "Option::is_none")]
+    pub feature_name: Option<String>,
+    #[serde(rename = "featureType", default, skip_serializing_if = "Option::is_none")]
+    pub feature_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExposureControlResponse {
+    #[serde(rename = "featureName", default, skip_serializing_if = "Option::is_none")]
+    pub feature_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookReference {
+    #[serde(rename = "type")]
+    pub type_: synapse_notebook_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod synapse_notebook_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        NotebookReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobReference {
+    #[serde(rename = "type")]
+    pub type_: synapse_spark_job_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod synapse_spark_job_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SparkJobDefinitionReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolReference {
+    #[serde(rename = "type")]
+    pub type_: sql_pool_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod sql_pool_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlPoolReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ArtifactRenameRequest {
+    #[serde(rename = "newName", default, skip_serializing_if = "Option::is_none")]
+    pub new_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Pipeline {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub activities: Vec<Activity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub variables: Option<VariableDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub concurrency: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(rename = "runDimensions", default, skip_serializing_if = "Option::is_none")]
+    pub run_dimensions: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<pipeline::Folder>,
+}
+pub mod pipeline {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Activity {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "dependsOn", default, skip_serializing_if = "Vec::is_empty")]
+    pub depends_on: Vec<ActivityDependency>,
+    #[serde(rename = "userProperties", default, skip_serializing_if = "Vec::is_empty")]
+    pub user_properties: Vec<UserProperty>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserProperty {
+    pub name: String,
+    pub value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityDependency {
+    pub activity: String,
+    #[serde(rename = "dependencyConditions")]
+    pub dependency_conditions: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ControlActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutionActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub policy: Option<ActivityPolicy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub retry: Option<serde_json::Value>,
+    #[serde(rename = "retryIntervalInSeconds", default, skip_serializing_if = "Option::is_none")]
+    pub retry_interval_in_seconds: Option<i64>,
+    #[serde(rename = "secureInput", default, skip_serializing_if = "Option::is_none")]
+    pub secure_input: Option<bool>,
+    #[serde(rename = "secureOutput", default, skip_serializing_if = "Option::is_none")]
+    pub secure_output: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoreReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "listAfter", default, skip_serializing_if = "Option::is_none")]
+    pub list_after: Option<serde_json::Value>,
+    #[serde(rename = "listBefore", default, skip_serializing_if = "Option::is_none")]
+    pub list_before: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3ReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(rename = "fileFilter", default, skip_serializing_if = "Option::is_none")]
+    pub file_filter: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "operationTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub operation_timeout: Option<serde_json::Value>,
+    #[serde(rename = "useTempFileRename", default, skip_serializing_if = "Option::is_none")]
+    pub use_temp_file_rename: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "useBinaryTransfer", default, skip_serializing_if = "Option::is_none")]
+    pub use_binary_transfer: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "requestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(rename = "distcpSettings", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_settings: Option<DistcpSettings>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoreWriteSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "blockSizeInMB", default, skip_serializing_if = "Option::is_none")]
+    pub block_size_in_mb: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "blockSizeInMB", default, skip_serializing_if = "Option::is_none")]
+    pub block_size_in_mb: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "expiryDateTime", default, skip_serializing_if = "Option::is_none")]
+    pub expiry_date_time: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FormatReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompressionReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZipDeflateReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveZipFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_zip_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TarReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveCompressionFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_compression_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TarGZipReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveCompressionFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_compression_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "skipLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_line_count: Option<serde_json::Value>,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+    #[serde(rename = "validationMode", default, skip_serializing_if = "Option::is_none")]
+    pub validation_mode: Option<serde_json::Value>,
+    #[serde(rename = "detectDataType", default, skip_serializing_if = "Option::is_none")]
+    pub detect_data_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub namespaces: Option<serde_json::Value>,
+    #[serde(rename = "namespacePrefixes", default, skip_serializing_if = "Option::is_none")]
+    pub namespace_prefixes: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FormatWriteSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "recordName", default, skip_serializing_if = "Option::is_none")]
+    pub record_name: Option<String>,
+    #[serde(rename = "recordNamespace", default, skip_serializing_if = "Option::is_none")]
+    pub record_namespace: Option<String>,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "quoteAllText", default, skip_serializing_if = "Option::is_none")]
+    pub quote_all_text: Option<serde_json::Value>,
+    #[serde(rename = "fileExtension")]
+    pub file_extension: serde_json::Value,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "filePattern", default, skip_serializing_if = "Option::is_none")]
+    pub file_pattern: Option<json_write_settings::FilePattern>,
+}
+pub mod json_write_settings {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum FilePattern {
+        #[serde(rename = "setOfObjects")]
+        SetOfObjects,
+        #[serde(rename = "arrayOfObjects")]
+        ArrayOfObjects,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<DelimitedTextReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<JsonReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<XmlReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<DelimitedTextWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<JsonWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<OrcWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CopyActivityTypeProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub inputs: Vec<DatasetReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<DatasetReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivityTypeProperties {
+    pub source: CopySource,
+    pub sink: CopySink,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub translator: Option<serde_json::Value>,
+    #[serde(rename = "enableStaging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_staging: Option<serde_json::Value>,
+    #[serde(rename = "stagingSettings", default, skip_serializing_if = "Option::is_none")]
+    pub staging_settings: Option<StagingSettings>,
+    #[serde(rename = "parallelCopies", default, skip_serializing_if = "Option::is_none")]
+    pub parallel_copies: Option<serde_json::Value>,
+    #[serde(rename = "dataIntegrationUnits", default, skip_serializing_if = "Option::is_none")]
+    pub data_integration_units: Option<serde_json::Value>,
+    #[serde(rename = "enableSkipIncompatibleRow", default, skip_serializing_if = "Option::is_none")]
+    pub enable_skip_incompatible_row: Option<serde_json::Value>,
+    #[serde(rename = "redirectIncompatibleRowSettings", default, skip_serializing_if = "Option::is_none")]
+    pub redirect_incompatible_row_settings: Option<RedirectIncompatibleRowSettings>,
+    #[serde(rename = "logStorageSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_storage_settings: Option<LogStorageSettings>,
+    #[serde(rename = "logSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_settings: Option<LogSettings>,
+    #[serde(rename = "preserveRules", default, skip_serializing_if = "Vec::is_empty")]
+    pub preserve_rules: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub preserve: Vec<serde_json::Value>,
+    #[serde(rename = "validateDataConsistency", default, skip_serializing_if = "Option::is_none")]
+    pub validate_data_consistency: Option<serde_json::Value>,
+    #[serde(rename = "skipErrorFile", default, skip_serializing_if = "Option::is_none")]
+    pub skip_error_file: Option<SkipErrorFile>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopySource {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "sourceRetryCount", default, skip_serializing_if = "Option::is_none")]
+    pub source_retry_count: Option<serde_json::Value>,
+    #[serde(rename = "sourceRetryWait", default, skip_serializing_if = "Option::is_none")]
+    pub source_retry_wait: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinarySource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<BinaryReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TabularSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "azureTableSourceQuery", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_source_query: Option<serde_json::Value>,
+    #[serde(rename = "azureTableSourceIgnoreTableNotFound", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_source_ignore_table_not_found: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipHeaderLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_header_line_count: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "pageSize", default, skip_serializing_if = "Option::is_none")]
+    pub page_size: Option<serde_json::Value>,
+    #[serde(rename = "preferredRegions", default, skip_serializing_if = "Option::is_none")]
+    pub preferred_regions: Option<serde_json::Value>,
+    #[serde(rename = "detectDatetime", default, skip_serializing_if = "Option::is_none")]
+    pub detect_datetime: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2Source {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "readBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub read_behavior: Option<salesforce_source::ReadBehavior>,
+}
+pub mod salesforce_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ReadBehavior {
+        Query,
+        QueryAll,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "readBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub read_behavior: Option<salesforce_service_cloud_source::ReadBehavior>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+pub mod salesforce_service_cloud_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ReadBehavior {
+        Query,
+        QueryAll,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "packetSize", default, skip_serializing_if = "Option::is_none")]
+    pub packet_size: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<sap_hana_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SapHanaPartitionSettings>,
+}
+pub mod sap_hana_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PhysicalPartitionsOfTable,
+        SapHanaDynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "excludeLastRequest", default, skip_serializing_if = "Option::is_none")]
+    pub exclude_last_request: Option<serde_json::Value>,
+    #[serde(rename = "baseRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub base_request_id: Option<serde_json::Value>,
+    #[serde(rename = "customRfcReadTableFunctionModule", default, skip_serializing_if = "Option::is_none")]
+    pub custom_rfc_read_table_function_module: Option<serde_json::Value>,
+    #[serde(rename = "sapDataColumnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub sap_data_column_delimiter: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "rowCount", default, skip_serializing_if = "Option::is_none")]
+    pub row_count: Option<serde_json::Value>,
+    #[serde(rename = "rowSkips", default, skip_serializing_if = "Option::is_none")]
+    pub row_skips: Option<serde_json::Value>,
+    #[serde(rename = "rfcTableFields", default, skip_serializing_if = "Option::is_none")]
+    pub rfc_table_fields: Option<serde_json::Value>,
+    #[serde(rename = "rfcTableOptions", default, skip_serializing_if = "Option::is_none")]
+    pub rfc_table_options: Option<serde_json::Value>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "customRfcReadTableFunctionModule", default, skip_serializing_if = "Option::is_none")]
+    pub custom_rfc_read_table_function_module: Option<serde_json::Value>,
+    #[serde(rename = "sapDataColumnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub sap_data_column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<sap_table_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SapTablePartitionSettings>,
+}
+pub mod sap_table_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PartitionOnInt,
+        PartitionOnCalendarYear,
+        PartitionOnCalendarMonth,
+        PartitionOnCalendarDate,
+        PartitionOnTime,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTablePartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+    #[serde(rename = "maxPartitionsNumber", default, skip_serializing_if = "Option::is_none")]
+    pub max_partitions_number: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "requestInterval", default, skip_serializing_if = "Option::is_none")]
+    pub request_interval: Option<serde_json::Value>,
+    #[serde(rename = "httpCompressionType", default, skip_serializing_if = "Option::is_none")]
+    pub http_compression_type: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "paginationRules", default, skip_serializing_if = "Option::is_none")]
+    pub pagination_rules: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "requestInterval", default, skip_serializing_if = "Option::is_none")]
+    pub request_interval: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "isolationLevel", default, skip_serializing_if = "Option::is_none")]
+    pub isolation_level: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlMiSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlDwSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSystemSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "distcpSettings", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_settings: Option<DistcpSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DistcpSettings {
+    #[serde(rename = "resourceManagerEndpoint")]
+    pub resource_manager_endpoint: serde_json::Value,
+    #[serde(rename = "tempScriptPath")]
+    pub temp_script_path: serde_json::Value,
+    #[serde(rename = "distcpOptions", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    pub query: serde_json::Value,
+    #[serde(rename = "noTruncation", default, skip_serializing_if = "Option::is_none")]
+    pub no_truncation: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "oracleReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub oracle_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<oracle_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<OraclePartitionSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+pub mod oracle_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PhysicalPartitionsOfTable,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OraclePartitionSettings {
+    #[serde(rename = "partitionNames", default, skip_serializing_if = "Option::is_none")]
+    pub partition_names: Option<serde_json::Value>,
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<teradata_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<TeradataPartitionSettings>,
+}
+pub mod teradata_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        Hash,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "consistencyLevel", default, skip_serializing_if = "Option::is_none")]
+    pub consistency_level: Option<cassandra_source::ConsistencyLevel>,
+}
+pub mod cassandra_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ConsistencyLevel {
+        #[serde(rename = "ALL")]
+        All,
+        #[serde(rename = "EACH_QUORUM")]
+        EachQuorum,
+        #[serde(rename = "QUORUM")]
+        Quorum,
+        #[serde(rename = "LOCAL_QUORUM")]
+        LocalQuorum,
+        #[serde(rename = "ONE")]
+        One,
+        #[serde(rename = "TWO")]
+        Two,
+        #[serde(rename = "THREE")]
+        Three,
+        #[serde(rename = "LOCAL_ONE")]
+        LocalOne,
+        #[serde(rename = "SERIAL")]
+        Serial,
+        #[serde(rename = "LOCAL_SERIAL")]
+        LocalSerial,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2Source {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_columns: Vec<AdditionalColumns>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCursorMethodsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sort: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skip: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365Source {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "allowedGroups", default, skip_serializing_if = "Option::is_none")]
+    pub allowed_groups: Option<serde_json::Value>,
+    #[serde(rename = "userScopeFilterUri", default, skip_serializing_if = "Option::is_none")]
+    pub user_scope_filter_uri: Option<serde_json::Value>,
+    #[serde(rename = "dateFilterColumn", default, skip_serializing_if = "Option::is_none")]
+    pub date_filter_column: Option<serde_json::Value>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<serde_json::Value>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<serde_json::Value>,
+    #[serde(rename = "outputColumns", default, skip_serializing_if = "Option::is_none")]
+    pub output_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipHeaderLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_header_line_count: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQuerySource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifySource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<netezza_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<NetezzaPartitionSettings>,
+}
+pub mod netezza_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        DataSlice,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "redshiftUnloadSettings", default, skip_serializing_if = "Option::is_none")]
+    pub redshift_unload_settings: Option<RedshiftUnloadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedshiftUnloadSettings {
+    #[serde(rename = "s3LinkedServiceName")]
+    pub s3_linked_service_name: LinkedServiceReference,
+    #[serde(rename = "bucketName")]
+    pub bucket_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "exportSettings", default, skip_serializing_if = "Option::is_none")]
+    pub export_settings: Option<SnowflakeExportCopyCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExportSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeExportCopyCommand {
+    #[serde(flatten)]
+    pub export_settings: ExportSettings,
+    #[serde(rename = "additionalCopyOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_copy_options: Option<serde_json::Value>,
+    #[serde(rename = "additionalFormatOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_format_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "exportSettings", default, skip_serializing_if = "Option::is_none")]
+    pub export_settings: Option<AzureDatabricksDeltaLakeExportCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeExportCommand {
+    #[serde(flatten)]
+    pub export_settings: ExportSettings,
+    #[serde(rename = "dateFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_format: Option<serde_json::Value>,
+    #[serde(rename = "timestampFormat", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_format: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "importSettings", default, skip_serializing_if = "Option::is_none")]
+    pub import_settings: Option<AzureDatabricksDeltaLakeImportCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeImportCommand {
+    #[serde(flatten)]
+    pub import_settings: ImportSettings,
+    #[serde(rename = "dateFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_format: Option<serde_json::Value>,
+    #[serde(rename = "timestampFormat", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_format: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoredProcedureParameter {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<StoredProcedureParameterType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum StoredProcedureParameterType {
+    String,
+    Int,
+    Int64,
+    Decimal,
+    Guid,
+    Boolean,
+    Date,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopySink {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "writeBatchSize", default, skip_serializing_if = "Option::is_none")]
+    pub write_batch_size: Option<serde_json::Value>,
+    #[serde(rename = "writeBatchTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub write_batch_timeout: Option<serde_json::Value>,
+    #[serde(rename = "sinkRetryCount", default, skip_serializing_if = "Option::is_none")]
+    pub sink_retry_count: Option<serde_json::Value>,
+    #[serde(rename = "sinkRetryWait", default, skip_serializing_if = "Option::is_none")]
+    pub sink_retry_wait: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<sap_cloud_for_customer_sink::WriteBehavior>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+pub mod sap_cloud_for_customer_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Update,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureQueueSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum CopyBehaviorType {
+    PreserveHierarchy,
+    FlattenHierarchy,
+    MergeFiles,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "azureTableDefaultPartitionKeyValue", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_default_partition_key_value: Option<serde_json::Value>,
+    #[serde(rename = "azureTablePartitionKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_partition_key_name: Option<serde_json::Value>,
+    #[serde(rename = "azureTableRowKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_row_key_name: Option<serde_json::Value>,
+    #[serde(rename = "azureTableInsertType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_insert_type: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<AvroWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<ParquetWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinarySink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "blobWriterOverwriteFiles", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_overwrite_files: Option<serde_json::Value>,
+    #[serde(rename = "blobWriterDateTimeFormat", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_date_time_format: Option<serde_json::Value>,
+    #[serde(rename = "blobWriterAddHeader", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_add_header: Option<serde_json::Value>,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSystemSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlMiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlDwSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "allowPolyBase", default, skip_serializing_if = "Option::is_none")]
+    pub allow_poly_base: Option<serde_json::Value>,
+    #[serde(rename = "polyBaseSettings", default, skip_serializing_if = "Option::is_none")]
+    pub poly_base_settings: Option<PolybaseSettings>,
+    #[serde(rename = "allowCopyCommand", default, skip_serializing_if = "Option::is_none")]
+    pub allow_copy_command: Option<serde_json::Value>,
+    #[serde(rename = "copyCommandSettings", default, skip_serializing_if = "Option::is_none")]
+    pub copy_command_settings: Option<DwCopyCommandSettings>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolybaseSettings {
+    #[serde(rename = "rejectType", default, skip_serializing_if = "Option::is_none")]
+    pub reject_type: Option<PolybaseSettingsRejectType>,
+    #[serde(rename = "rejectValue", default, skip_serializing_if = "Option::is_none")]
+    pub reject_value: Option<serde_json::Value>,
+    #[serde(rename = "rejectSampleValue", default, skip_serializing_if = "Option::is_none")]
+    pub reject_sample_value: Option<serde_json::Value>,
+    #[serde(rename = "useTypeDefault", default, skip_serializing_if = "Option::is_none")]
+    pub use_type_default: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum PolybaseSettingsRejectType {
+    #[serde(rename = "value")]
+    Value,
+    #[serde(rename = "percentage")]
+    Percentage,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DwCopyCommandSettings {
+    #[serde(rename = "defaultValues", default, skip_serializing_if = "Vec::is_empty")]
+    pub default_values: Vec<DwCopyCommandDefaultValue>,
+    #[serde(rename = "additionalOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DwCopyCommandDefaultValue {
+    #[serde(rename = "columnName", default, skip_serializing_if = "Option::is_none")]
+    pub column_name: Option<serde_json::Value>,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "importSettings", default, skip_serializing_if = "Option::is_none")]
+    pub import_settings: Option<SnowflakeImportCopyCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeImportCopyCommand {
+    #[serde(flatten)]
+    pub import_settings: ImportSettings,
+    #[serde(rename = "additionalCopyOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_copy_options: Option<serde_json::Value>,
+    #[serde(rename = "additionalFormatOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_format_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogStorageSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
+    pub log_level: Option<serde_json::Value>,
+    #[serde(rename = "enableReliableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_reliable_logging: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogSettings {
+    #[serde(rename = "enableCopyActivityLog", default, skip_serializing_if = "Option::is_none")]
+    pub enable_copy_activity_log: Option<serde_json::Value>,
+    #[serde(rename = "copyActivityLogSettings", default, skip_serializing_if = "Option::is_none")]
+    pub copy_activity_log_settings: Option<CopyActivityLogSettings>,
+    #[serde(rename = "logLocationSettings")]
+    pub log_location_settings: LogLocationSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogLocationSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivityLogSettings {
+    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
+    pub log_level: Option<serde_json::Value>,
+    #[serde(rename = "enableReliableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_reliable_logging: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StagingSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+    #[serde(rename = "enableCompression", default, skip_serializing_if = "Option::is_none")]
+    pub enable_compression: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedirectIncompatibleRowSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SkipErrorFile {
+    #[serde(rename = "fileMissing", default, skip_serializing_if = "Option::is_none")]
+    pub file_missing: Option<serde_json::Value>,
+    #[serde(rename = "dataInconsistency", default, skip_serializing_if = "Option::is_none")]
+    pub data_inconsistency: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdditionalColumns {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+    #[serde(rename = "enableAdlsSingleFileParallel", default, skip_serializing_if = "Option::is_none")]
+    pub enable_adls_single_file_parallel: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<azure_search_index_sink::WriteBehavior>,
+}
+pub mod azure_search_index_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Merge,
+        Upload,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsSinkWriteBehavior {
+    Upsert,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "ingestionMappingName", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_mapping_name: Option<serde_json::Value>,
+    #[serde(rename = "ingestionMappingAsJson", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_mapping_as_json: Option<serde_json::Value>,
+    #[serde(rename = "flushImmediately", default, skip_serializing_if = "Option::is_none")]
+    pub flush_immediately: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<salesforce_sink::WriteBehavior>,
+    #[serde(rename = "externalIdFieldName", default, skip_serializing_if = "Option::is_none")]
+    pub external_id_field_name: Option<serde_json::Value>,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+}
+pub mod salesforce_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Upsert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<salesforce_service_cloud_sink::WriteBehavior>,
+    #[serde(rename = "externalIdFieldName", default, skip_serializing_if = "Option::is_none")]
+    pub external_id_field_name: Option<serde_json::Value>,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+}
+pub mod salesforce_service_cloud_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Upsert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyTranslator {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TabularTranslator {
+    #[serde(flatten)]
+    pub copy_translator: CopyTranslator,
+    #[serde(rename = "columnMappings", default, skip_serializing_if = "Option::is_none")]
+    pub column_mappings: Option<serde_json::Value>,
+    #[serde(rename = "schemaMapping", default, skip_serializing_if = "Option::is_none")]
+    pub schema_mapping: Option<serde_json::Value>,
+    #[serde(rename = "collectionReference", default, skip_serializing_if = "Option::is_none")]
+    pub collection_reference: Option<serde_json::Value>,
+    #[serde(rename = "mapComplexValuesToString", default, skip_serializing_if = "Option::is_none")]
+    pub map_complex_values_to_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mappings: Option<serde_json::Value>,
+    #[serde(rename = "typeConversion", default, skip_serializing_if = "Option::is_none")]
+    pub type_conversion: Option<serde_json::Value>,
+    #[serde(rename = "typeConversionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub type_conversion_settings: Option<TypeConversionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypeConversionSettings {
+    #[serde(rename = "allowDataTruncation", default, skip_serializing_if = "Option::is_none")]
+    pub allow_data_truncation: Option<serde_json::Value>,
+    #[serde(rename = "treatBooleanAsNumber", default, skip_serializing_if = "Option::is_none")]
+    pub treat_boolean_as_number: Option<serde_json::Value>,
+    #[serde(rename = "dateTimeFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_time_format: Option<serde_json::Value>,
+    #[serde(rename = "dateTimeOffsetFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_time_offset_format: Option<serde_json::Value>,
+    #[serde(rename = "timeSpanFormat", default, skip_serializing_if = "Option::is_none")]
+    pub time_span_format: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub culture: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightHiveActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightHiveActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightHiveActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "scriptPath", default, skip_serializing_if = "Option::is_none")]
+    pub script_path: Option<serde_json::Value>,
+    #[serde(rename = "scriptLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub script_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub variables: Vec<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum HdInsightActivityDebugInfoOption {
+    None,
+    Always,
+    Failure,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightPigActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightPigActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightPigActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub arguments: Option<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "scriptPath", default, skip_serializing_if = "Option::is_none")]
+    pub script_path: Option<serde_json::Value>,
+    #[serde(rename = "scriptLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub script_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightMapReduceActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightMapReduceActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightMapReduceActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "className")]
+    pub class_name: serde_json::Value,
+    #[serde(rename = "jarFilePath")]
+    pub jar_file_path: serde_json::Value,
+    #[serde(rename = "jarLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub jar_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "jarLibs", default, skip_serializing_if = "Vec::is_empty")]
+    pub jar_libs: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightStreamingActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightStreamingActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightStreamingActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    pub mapper: serde_json::Value,
+    pub reducer: serde_json::Value,
+    pub input: serde_json::Value,
+    pub output: serde_json::Value,
+    #[serde(rename = "filePaths")]
+    pub file_paths: Vec<serde_json::Value>,
+    #[serde(rename = "fileLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub file_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub combiner: Option<serde_json::Value>,
+    #[serde(rename = "commandEnvironment", default, skip_serializing_if = "Vec::is_empty")]
+    pub command_environment: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightSparkActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightSparkActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightSparkActivityTypeProperties {
+    #[serde(rename = "rootPath")]
+    pub root_path: serde_json::Value,
+    #[serde(rename = "entryFilePath")]
+    pub entry_file_path: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "sparkJobLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub spark_job_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(rename = "proxyUser", default, skip_serializing_if = "Option::is_none")]
+    pub proxy_user: Option<serde_json::Value>,
+    #[serde(rename = "sparkConfig", default, skip_serializing_if = "Option::is_none")]
+    pub spark_config: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteSsisPackageActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecuteSsisPackageActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteSsisPackageActivityTypeProperties {
+    #[serde(rename = "packageLocation")]
+    pub package_location: SsisPackageLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub runtime: Option<serde_json::Value>,
+    #[serde(rename = "loggingLevel", default, skip_serializing_if = "Option::is_none")]
+    pub logging_level: Option<serde_json::Value>,
+    #[serde(rename = "environmentPath", default, skip_serializing_if = "Option::is_none")]
+    pub environment_path: Option<serde_json::Value>,
+    #[serde(rename = "executionCredential", default, skip_serializing_if = "Option::is_none")]
+    pub execution_credential: Option<SsisExecutionCredential>,
+    #[serde(rename = "connectVia")]
+    pub connect_via: IntegrationRuntimeReference,
+    #[serde(rename = "projectParameters", default, skip_serializing_if = "Option::is_none")]
+    pub project_parameters: Option<serde_json::Value>,
+    #[serde(rename = "packageParameters", default, skip_serializing_if = "Option::is_none")]
+    pub package_parameters: Option<serde_json::Value>,
+    #[serde(rename = "projectConnectionManagers", default, skip_serializing_if = "Option::is_none")]
+    pub project_connection_managers: Option<serde_json::Value>,
+    #[serde(rename = "packageConnectionManagers", default, skip_serializing_if = "Option::is_none")]
+    pub package_connection_managers: Option<serde_json::Value>,
+    #[serde(rename = "propertyOverrides", default, skip_serializing_if = "Option::is_none")]
+    pub property_overrides: Option<serde_json::Value>,
+    #[serde(rename = "logLocation", default, skip_serializing_if = "Option::is_none")]
+    pub log_location: Option<SsisLogLocation>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPackageLocation {
+    #[serde(rename = "packagePath", default, skip_serializing_if = "Option::is_none")]
+    pub package_path: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<ssis_package_location::Type>,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SsisPackageLocationTypeProperties>,
+}
+pub mod ssis_package_location {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "SSISDB")]
+        Ssisdb,
+        File,
+        InlinePackage,
+        PackageStore,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPackageLocationTypeProperties {
+    #[serde(rename = "packagePassword", default, skip_serializing_if = "Option::is_none")]
+    pub package_password: Option<SecretBase>,
+    #[serde(rename = "accessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "configurationPath", default, skip_serializing_if = "Option::is_none")]
+    pub configuration_path: Option<serde_json::Value>,
+    #[serde(rename = "configurationAccessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub configuration_access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(rename = "packageContent", default, skip_serializing_if = "Option::is_none")]
+    pub package_content: Option<serde_json::Value>,
+    #[serde(rename = "packageLastModifiedDate", default, skip_serializing_if = "Option::is_none")]
+    pub package_last_modified_date: Option<String>,
+    #[serde(rename = "childPackages", default, skip_serializing_if = "Vec::is_empty")]
+    pub child_packages: Vec<SsisChildPackage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisConnectionManager {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisExecutionParameter {
+    pub value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPropertyOverride {
+    pub value: serde_json::Value,
+    #[serde(rename = "isSensitive", default, skip_serializing_if = "Option::is_none")]
+    pub is_sensitive: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisExecutionCredential {
+    pub domain: serde_json::Value,
+    #[serde(rename = "userName")]
+    pub user_name: serde_json::Value,
+    pub password: SecureString,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisAccessCredential {
+    pub domain: serde_json::Value,
+    #[serde(rename = "userName")]
+    pub user_name: serde_json::Value,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisChildPackage {
+    #[serde(rename = "packagePath")]
+    pub package_path: serde_json::Value,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(rename = "packageContent")]
+    pub package_content: serde_json::Value,
+    #[serde(rename = "packageLastModifiedDate", default, skip_serializing_if = "Option::is_none")]
+    pub package_last_modified_date: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisLogLocation {
+    #[serde(rename = "logPath")]
+    pub log_path: serde_json::Value,
+    #[serde(rename = "type")]
+    pub type_: ssis_log_location::Type,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SsisLogLocationTypeProperties,
+}
+pub mod ssis_log_location {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        File,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisLogLocationTypeProperties {
+    #[serde(rename = "accessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "logRefreshInterval", default, skip_serializing_if = "Option::is_none")]
+    pub log_refresh_interval: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CustomActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivityTypeProperties {
+    pub command: serde_json::Value,
+    #[serde(rename = "resourceLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub resource_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "referenceObjects", default, skip_serializing_if = "Option::is_none")]
+    pub reference_objects: Option<CustomActivityReferenceObject>,
+    #[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<serde_json::Value>,
+    #[serde(rename = "retentionTimeInDays", default, skip_serializing_if = "Option::is_none")]
+    pub retention_time_in_days: Option<serde_json::Value>,
+    #[serde(rename = "autoUserSpecification", default, skip_serializing_if = "Option::is_none")]
+    pub auto_user_specification: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivityReferenceObject {
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerStoredProcedureActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlServerStoredProcedureActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerStoredProcedureActivityTypeProperties {
+    #[serde(rename = "storedProcedureName")]
+    pub stored_procedure_name: serde_json::Value,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutePipelineActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecutePipelineActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutePipelineActivityTypeProperties {
+    pub pipeline: PipelineReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+    #[serde(rename = "waitOnCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub wait_on_completion: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DeleteActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteActivityTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<i64>,
+    #[serde(rename = "enableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_logging: Option<serde_json::Value>,
+    #[serde(rename = "logStorageSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_storage_settings: Option<LogStorageSettings>,
+    pub dataset: DatasetReference,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCommandActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerCommandActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCommandActivityTypeProperties {
+    pub command: serde_json::Value,
+    #[serde(rename = "commandTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub command_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LookupActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: LookupActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LookupActivityTypeProperties {
+    pub source: CopySource,
+    pub dataset: DatasetReference,
+    #[serde(rename = "firstRowOnly", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_only: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum WebActivityMethod {
+    #[serde(rename = "GET")]
+    Get,
+    #[serde(rename = "POST")]
+    Post,
+    #[serde(rename = "PUT")]
+    Put,
+    #[serde(rename = "DELETE")]
+    Delete,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivityAuthentication {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pfx: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivityTypeProperties {
+    pub method: WebActivityMethod,
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<WebActivityAuthentication>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetReference>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceReference>,
+    #[serde(rename = "connectVia", default, skip_serializing_if = "Option::is_none")]
+    pub connect_via: Option<IntegrationRuntimeReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetMetadataActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GetMetadataActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetMetadataActivityTypeProperties {
+    pub dataset: DatasetReference,
+    #[serde(rename = "fieldList", default, skip_serializing_if = "Vec::is_empty")]
+    pub field_list: Vec<serde_json::Value>,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<FormatReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IfConditionActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: IfConditionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IfConditionActivityTypeProperties {
+    pub expression: Expression,
+    #[serde(rename = "ifTrueActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub if_true_activities: Vec<Activity>,
+    #[serde(rename = "ifFalseActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub if_false_activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SwitchActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchActivityTypeProperties {
+    pub on: Expression,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub cases: Vec<SwitchCase>,
+    #[serde(rename = "defaultActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub default_activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchCase {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ForEachActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ForEachActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ForEachActivityTypeProperties {
+    #[serde(rename = "isSequential", default, skip_serializing_if = "Option::is_none")]
+    pub is_sequential: Option<bool>,
+    #[serde(rename = "batchCount", default, skip_serializing_if = "Option::is_none")]
+    pub batch_count: Option<i64>,
+    pub items: Expression,
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlBatchExecutionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlBatchExecutionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlBatchExecutionActivityTypeProperties {
+    #[serde(rename = "globalParameters", default, skip_serializing_if = "Option::is_none")]
+    pub global_parameters: Option<serde_json::Value>,
+    #[serde(rename = "webServiceOutputs", default, skip_serializing_if = "Option::is_none")]
+    pub web_service_outputs: Option<serde_json::Value>,
+    #[serde(rename = "webServiceInputs", default, skip_serializing_if = "Option::is_none")]
+    pub web_service_inputs: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlWebServiceFile {
+    #[serde(rename = "filePath")]
+    pub file_path: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlUpdateResourceActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlUpdateResourceActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlUpdateResourceActivityTypeProperties {
+    #[serde(rename = "trainedModelName")]
+    pub trained_model_name: serde_json::Value,
+    #[serde(rename = "trainedModelLinkedServiceName")]
+    pub trained_model_linked_service_name: LinkedServiceReference,
+    #[serde(rename = "trainedModelFilePath")]
+    pub trained_model_file_path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlExecutePipelineActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlExecutePipelineActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlExecutePipelineActivityTypeProperties {
+    #[serde(rename = "mlPipelineId")]
+    pub ml_pipeline_id: serde_json::Value,
+    #[serde(rename = "experimentName", default, skip_serializing_if = "Option::is_none")]
+    pub experiment_name: Option<serde_json::Value>,
+    #[serde(rename = "mlPipelineParameters", default, skip_serializing_if = "Option::is_none")]
+    pub ml_pipeline_parameters: Option<serde_json::Value>,
+    #[serde(rename = "mlParentRunId", default, skip_serializing_if = "Option::is_none")]
+    pub ml_parent_run_id: Option<serde_json::Value>,
+    #[serde(rename = "continueOnStepFailure", default, skip_serializing_if = "Option::is_none")]
+    pub continue_on_step_failure: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlPipelineParameters {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsUsqlActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DataLakeAnalyticsUsqlActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsUsqlActivityTypeProperties {
+    #[serde(rename = "scriptPath")]
+    pub script_path: serde_json::Value,
+    #[serde(rename = "scriptLinkedService")]
+    pub script_linked_service: LinkedServiceReference,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<serde_json::Value>,
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<serde_json::Value>,
+    #[serde(rename = "compilationMode", default, skip_serializing_if = "Option::is_none")]
+    pub compilation_mode: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WaitActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WaitActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WaitActivityTypeProperties {
+    #[serde(rename = "waitTimeInSeconds")]
+    pub wait_time_in_seconds: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UntilActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: UntilActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UntilActivityTypeProperties {
+    pub expression: Expression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ValidationActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ValidationActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ValidationActivityTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sleep: Option<serde_json::Value>,
+    #[serde(rename = "minimumSize", default, skip_serializing_if = "Option::is_none")]
+    pub minimum_size: Option<serde_json::Value>,
+    #[serde(rename = "childItems", default, skip_serializing_if = "Option::is_none")]
+    pub child_items: Option<serde_json::Value>,
+    pub dataset: DatasetReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FilterActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterActivityTypeProperties {
+    pub items: Expression,
+    pub condition: Expression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksNotebookActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksNotebookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksNotebookActivityTypeProperties {
+    #[serde(rename = "notebookPath")]
+    pub notebook_path: serde_json::Value,
+    #[serde(rename = "baseParameters", default, skip_serializing_if = "Option::is_none")]
+    pub base_parameters: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkJarActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksSparkJarActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkJarActivityTypeProperties {
+    #[serde(rename = "mainClassName")]
+    pub main_class_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkPythonActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksSparkPythonActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkPythonActivityTypeProperties {
+    #[serde(rename = "pythonFile")]
+    pub python_file: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetVariableActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SetVariableActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetVariableActivityTypeProperties {
+    #[serde(rename = "variableName", default, skip_serializing_if = "Option::is_none")]
+    pub variable_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppendVariableActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AppendVariableActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppendVariableActivityTypeProperties {
+    #[serde(rename = "variableName", default, skip_serializing_if = "Option::is_none")]
+    pub variable_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AzureFunctionActivityMethod {
+    #[serde(rename = "GET")]
+    Get,
+    #[serde(rename = "POST")]
+    Post,
+    #[serde(rename = "PUT")]
+    Put,
+    #[serde(rename = "DELETE")]
+    Delete,
+    #[serde(rename = "OPTIONS")]
+    Options,
+    #[serde(rename = "HEAD")]
+    Head,
+    #[serde(rename = "TRACE")]
+    Trace,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFunctionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionActivityTypeProperties {
+    pub method: AzureFunctionActivityMethod,
+    #[serde(rename = "functionName")]
+    pub function_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebHookActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebHookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum WebHookActivityMethod {
+    #[serde(rename = "POST")]
+    Post,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebHookActivityTypeProperties {
+    pub method: WebHookActivityMethod,
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<WebActivityAuthentication>,
+    #[serde(rename = "reportStatusOnCallBack", default, skip_serializing_if = "Option::is_none")]
+    pub report_status_on_call_back: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteDataFlowActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecuteDataFlowActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteDataFlowActivityTypeProperties {
+    pub dataflow: DataFlowReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<DataFlowStagingInfo>,
+    #[serde(rename = "integrationRuntime", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime: Option<IntegrationRuntimeReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<execute_data_flow_activity_type_properties::Compute>,
+    #[serde(rename = "traceLevel", default, skip_serializing_if = "Option::is_none")]
+    pub trace_level: Option<serde_json::Value>,
+    #[serde(rename = "continueOnError", default, skip_serializing_if = "Option::is_none")]
+    pub continue_on_error: Option<serde_json::Value>,
+    #[serde(rename = "runConcurrently", default, skip_serializing_if = "Option::is_none")]
+    pub run_concurrently: Option<serde_json::Value>,
+}
+pub mod execute_data_flow_activity_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Compute {
+        #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+        pub compute_type: Option<compute::ComputeType>,
+        #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+        pub core_count: Option<i64>,
+    }
+    pub mod compute {
+        use super::*;
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        pub enum ComputeType {
+            General,
+            MemoryOptimized,
+            ComputeOptimized,
+        }
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SqlPartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SapHanaPartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    SapHanaDynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SapTablePartitionOption {
+    None,
+    PartitionOnInt,
+    PartitionOnCalendarYear,
+    PartitionOnCalendarMonth,
+    PartitionOnCalendarDate,
+    PartitionOnTime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum OraclePartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TeradataPartitionOption {
+    None,
+    Hash,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum NetezzaPartitionOption {
+    None,
+    DataSlice,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SynapseNotebookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookActivityTypeProperties {
+    pub notebook: SynapseNotebookReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobDefinitionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SynapseSparkJobActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobActivityTypeProperties {
+    #[serde(rename = "sparkJob")]
+    pub spark_job: SynapseSparkJobReference,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolStoredProcedureActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+    #[serde(rename = "sqlPool")]
+    pub sql_pool: SqlPoolReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlPoolStoredProcedureActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolStoredProcedureActivityTypeProperties {
+    #[serde(rename = "storedProcedureName")]
+    pub stored_procedure_name: serde_json::Value,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Trigger {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "runtimeState", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_state: Option<TriggerRuntimeState>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TriggerRuntimeState {
+    Started,
+    Stopped,
+    Disabled,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MultiplePipelineTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub pipelines: Vec<TriggerPipelineReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScheduleTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: schedule_trigger::TypeProperties,
+}
+pub mod schedule_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        pub recurrence: ScheduleTriggerRecurrence,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScheduleTriggerRecurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub frequency: Option<RecurrenceFrequency>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub interval: Option<i32>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(rename = "timeZone", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule: Option<RecurrenceSchedule>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum RecurrenceFrequency {
+    NotSpecified,
+    Minute,
+    Hour,
+    Day,
+    Week,
+    Month,
+    Year,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceSchedule {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub minutes: Vec<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub hours: Vec<i32>,
+    #[serde(rename = "weekDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub week_days: Vec<String>,
+    #[serde(rename = "monthDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub month_days: Vec<i32>,
+    #[serde(rename = "monthlyOccurrences", default, skip_serializing_if = "Vec::is_empty")]
+    pub monthly_occurrences: Vec<RecurrenceScheduleOccurrence>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceScheduleOccurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub day: Option<DayOfWeek>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub occurrence: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DayOfWeek {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: blob_trigger::TypeProperties,
+}
+pub mod blob_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "folderPath")]
+        pub folder_path: String,
+        #[serde(rename = "maxConcurrency")]
+        pub max_concurrency: i64,
+        #[serde(rename = "linkedService")]
+        pub linked_service: LinkedServiceReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobEventsTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: blob_events_trigger::TypeProperties,
+}
+pub mod blob_events_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "blobPathBeginsWith", default, skip_serializing_if = "Option::is_none")]
+        pub blob_path_begins_with: Option<String>,
+        #[serde(rename = "blobPathEndsWith", default, skip_serializing_if = "Option::is_none")]
+        pub blob_path_ends_with: Option<String>,
+        #[serde(rename = "ignoreEmptyBlobs", default, skip_serializing_if = "Option::is_none")]
+        pub ignore_empty_blobs: Option<bool>,
+        pub events: BlobEventTypes,
+        pub scope: String,
+    }
+}
+pub type BlobEventTypes = Vec<String>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomEventsTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: custom_events_trigger::TypeProperties,
+}
+pub mod custom_events_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "subjectBeginsWith", default, skip_serializing_if = "Option::is_none")]
+        pub subject_begins_with: Option<String>,
+        #[serde(rename = "subjectEndsWith", default, skip_serializing_if = "Option::is_none")]
+        pub subject_ends_with: Option<String>,
+        pub events: Vec<serde_json::Value>,
+        pub scope: String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TumblingWindowTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    pub pipeline: TriggerPipelineReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: tumbling_window_trigger::TypeProperties,
+}
+pub mod tumbling_window_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        pub frequency: TumblingWindowFrequency,
+        pub interval: i32,
+        #[serde(rename = "startTime")]
+        pub start_time: String,
+        #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+        pub end_time: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub delay: Option<serde_json::Value>,
+        #[serde(rename = "maxConcurrency")]
+        pub max_concurrency: i64,
+        #[serde(rename = "retryPolicy", default, skip_serializing_if = "Option::is_none")]
+        pub retry_policy: Option<RetryPolicy>,
+        #[serde(rename = "dependsOn", default, skip_serializing_if = "Vec::is_empty")]
+        pub depends_on: Vec<DependencyReference>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TumblingWindowFrequency {
+    Minute,
+    Hour,
+    Month,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RetryPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<serde_json::Value>,
+    #[serde(rename = "intervalInSeconds", default, skip_serializing_if = "Option::is_none")]
+    pub interval_in_seconds: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerReference {
+    #[serde(rename = "type")]
+    pub type_: trigger_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod trigger_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        TriggerReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DependencyReference {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerDependencyReference {
+    #[serde(flatten)]
+    pub dependency_reference: DependencyReference,
+    #[serde(rename = "referenceTrigger")]
+    pub reference_trigger: TriggerReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TumblingWindowTriggerDependencyReference {
+    #[serde(flatten)]
+    pub trigger_dependency_reference: TriggerDependencyReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offset: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SelfDependencyTumblingWindowTriggerReference {
+    #[serde(flatten)]
+    pub dependency_reference: DependencyReference,
+    pub offset: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTumblingWindowTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: rerun_tumbling_window_trigger::TypeProperties,
+}
+pub mod rerun_tumbling_window_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "parentTrigger")]
+        pub parent_trigger: serde_json::Value,
+        #[serde(rename = "requestedStartTime")]
+        pub requested_start_time: String,
+        #[serde(rename = "requestedEndTime")]
+        pub requested_end_time: String,
+        #[serde(rename = "rerunConcurrency")]
+        pub rerun_concurrency: i64,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ChainingTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    pub pipeline: TriggerPipelineReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: chaining_trigger::TypeProperties,
+}
+pub mod chaining_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "dependsOn")]
+        pub depends_on: Vec<PipelineReference>,
+        #[serde(rename = "runDimension")]
+        pub run_dimension: String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Dataset {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub structure: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<dataset::Folder>,
+}
+pub mod dataset {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetLocation {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub container: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "fileSystem", default, skip_serializing_if = "Option::is_none")]
+    pub file_system: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Location {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "bucketName", default, skip_serializing_if = "Option::is_none")]
+    pub bucket_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "bucketName", default, skip_serializing_if = "Option::is_none")]
+    pub bucket_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDataElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetSchemaDataElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetStorageFormat {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub serializer: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub deserializer: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TextFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+    #[serde(rename = "columnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "rowDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub row_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "escapeChar", default, skip_serializing_if = "Option::is_none")]
+    pub escape_char: Option<serde_json::Value>,
+    #[serde(rename = "quoteChar", default, skip_serializing_if = "Option::is_none")]
+    pub quote_char: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_line_count: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+    #[serde(rename = "filePattern", default, skip_serializing_if = "Option::is_none")]
+    pub file_pattern: Option<JsonFormatFilePattern>,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "jsonNodeReference", default, skip_serializing_if = "Option::is_none")]
+    pub json_node_reference: Option<serde_json::Value>,
+    #[serde(rename = "jsonPathDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub json_path_definition: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JsonFormatFilePattern {
+    #[serde(rename = "setOfObjects")]
+    SetOfObjects,
+    #[serde(rename = "arrayOfObjects")]
+    ArrayOfObjects,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetCompression {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetBZip2Compression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetGZipCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<CompressionLevel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDeflateCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<CompressionLevel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetZipDeflateCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<CompressionLevel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetTarCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetTarGZipCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<CompressionLevel>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompressionLevel {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DatasetCompressionLevelEnum {
+    Optimal,
+    Fastest,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Dataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonS3DatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3DatasetTypeProperties {
+    #[serde(rename = "bucketName")]
+    pub bucket_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AvroDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "avroCompressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub avro_compression_codec: Option<serde_json::Value>,
+    #[serde(rename = "avroCompressionLevel", default, skip_serializing_if = "Option::is_none")]
+    pub avro_compression_level: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AvroCompressionCodecEnum {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "deflate")]
+    Deflate,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "xz")]
+    Xz,
+    #[serde(rename = "bzip2")]
+    Bzip2,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ExcelDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "sheetName")]
+    pub sheet_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub range: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ParquetDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "compressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub compression_codec: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ParquetCompressionCodecEnum {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "gzip")]
+    Gzip,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lzo")]
+    Lzo,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DelimitedTextDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "columnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "rowDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub row_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "compressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub compression_codec: Option<delimited_text_dataset_type_properties::CompressionCodec>,
+    #[serde(rename = "compressionLevel", default, skip_serializing_if = "Option::is_none")]
+    pub compression_level: Option<CompressionLevel>,
+    #[serde(rename = "quoteChar", default, skip_serializing_if = "Option::is_none")]
+    pub quote_char: Option<serde_json::Value>,
+    #[serde(rename = "escapeChar", default, skip_serializing_if = "Option::is_none")]
+    pub escape_char: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+}
+pub mod delimited_text_dataset_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CompressionCodec {
+        #[serde(rename = "bzip2")]
+        Bzip2,
+        #[serde(rename = "gzip")]
+        Gzip,
+        #[serde(rename = "deflate")]
+        Deflate,
+        #[serde(rename = "zipDeflate")]
+        ZipDeflate,
+        #[serde(rename = "snappy")]
+        Snappy,
+        #[serde(rename = "lz4")]
+        Lz4,
+        #[serde(rename = "tar")]
+        Tar,
+        #[serde(rename = "tarGZip")]
+        TarGZip,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<JsonDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<XmlDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OrcDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "orcCompressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub orc_compression_codec: Option<orc_dataset_type_properties::OrcCompressionCodec>,
+}
+pub mod orc_dataset_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OrcCompressionCodec {
+        #[serde(rename = "none")]
+        None,
+        #[serde(rename = "zlib")]
+        Zlib,
+        #[serde(rename = "snappy")]
+        Snappy,
+        #[serde(rename = "lzo")]
+        Lzo,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<BinaryDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureBlobDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "tableRootLocation", default, skip_serializing_if = "Option::is_none")]
+    pub table_root_location: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableDatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlMiTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlDwTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<CassandraTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub keyspace: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbSqlApiCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DocumentDbCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DynamicsEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DynamicsCrmEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<CommonDataServiceForAppsEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureDataLakeStoreDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureBlobFsDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365Dataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Office365DatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365DatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub predicate: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileShareDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<FileShareDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileShareDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(rename = "fileFilter", default, skip_serializing_if = "Option::is_none")]
+    pub file_filter: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbAtlasCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasCollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2CollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbV2CollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2CollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbMongoDbApiCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiCollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ODataResourceDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataResourceDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OracleTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<TeradataTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMySqlTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRedshiftTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2TableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<Db2TableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2TableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<RelationalTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<InformixTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OdbcTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MySqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PostgreSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MicrosoftAccessTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SalesforceObjectDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceObjectDatasetTypeProperties {
+    #[serde(rename = "objectApiName", default, skip_serializing_if = "Option::is_none")]
+    pub object_api_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SalesforceServiceCloudObjectDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudObjectDatasetTypeProperties {
+    #[serde(rename = "objectApiName", default, skip_serializing_if = "Option::is_none")]
+    pub object_api_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SybaseTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwCubeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapCloudForCustomerResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapEccResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SapHanaTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapOpenHubTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubTableDatasetTypeProperties {
+    #[serde(rename = "openHubDestinationName")]
+    pub open_hub_destination_name: serde_json::Value,
+    #[serde(rename = "excludeLastRequest", default, skip_serializing_if = "Option::is_none")]
+    pub exclude_last_request: Option<serde_json::Value>,
+    #[serde(rename = "baseRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub base_request_id: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SqlServerTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<RestResourceDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestResourceDatasetTypeProperties {
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "paginationRules", default, skip_serializing_if = "Option::is_none")]
+    pub pagination_rules: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapTableResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableResourceDatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebTableDatasetTypeProperties {
+    pub index: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSearchIndexDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexDatasetTypeProperties {
+    #[serde(rename = "indexName")]
+    pub index_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<HttpDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpDatasetTypeProperties {
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzurePostgreSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DrillDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GoogleBigQueryDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GreenplumDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<HiveDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ImpalaDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PhoenixDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PrestoDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SparkDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<NetezzaTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<VerticaDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsAxResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SnowflakeDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SharePointOnlineListDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListDatasetTypeProperties {
+    #[serde(rename = "listName", default, skip_serializing_if = "Option::is_none")]
+    pub list_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureDatabricksDeltaLakeDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedService {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "connectVia", default, skip_serializing_if = "Option::is_none")]
+    pub connect_via: Option<IntegrationRuntimeReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBlobStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "serviceEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub service_endpoint: Option<String>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlDwLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlDatabaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlMiLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBatchLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBatchLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBatchLinkedServiceTypeProperties {
+    #[serde(rename = "accountName")]
+    pub account_name: serde_json::Value,
+    #[serde(rename = "accessKey", default, skip_serializing_if = "Option::is_none")]
+    pub access_key: Option<SecretBase>,
+    #[serde(rename = "batchUri")]
+    pub batch_uri: serde_json::Value,
+    #[serde(rename = "poolName")]
+    pub pool_name: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureKeyVaultLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultLinkedServiceTypeProperties {
+    #[serde(rename = "baseUrl")]
+    pub base_url: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub account_endpoint: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: dynamics_linked_service_type_properties::DeploymentType,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: dynamics_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<dynamics_linked_service_type_properties::ServicePrincipalCredentialType>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod dynamics_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum DeploymentType {
+        Online,
+        OnPremisesWithIfd,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Office365,
+        Ifd,
+        #[serde(rename = "AADServicePrincipal")]
+        AadServicePrincipal,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServicePrincipalCredentialType {
+        ServicePrincipalKey,
+        ServicePrincipalCert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsCrmLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: dynamics_crm_linked_service_type_properties::DeploymentType,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: dynamics_crm_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod dynamics_crm_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum DeploymentType {
+        Online,
+        OnPremisesWithIfd,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Office365,
+        Ifd,
+        #[serde(rename = "AADServicePrincipal")]
+        AadServicePrincipal,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ServicePrincipalCredentialEnum {
+    ServicePrincipalKey,
+    ServicePrincipalCert,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CommonDataServiceForAppsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: common_data_service_for_apps_linked_service_type_properties::DeploymentType,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: common_data_service_for_apps_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod common_data_service_for_apps_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum DeploymentType {
+        Online,
+        OnPremisesWithIfd,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Office365,
+        Ifd,
+        #[serde(rename = "AADServicePrincipal")]
+        AadServicePrincipal,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightLinkedServiceTypeProperties {
+    #[serde(rename = "clusterUri")]
+    pub cluster_uri: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "hcatalogLinkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub hcatalog_linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "isEspEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_esp_enabled: Option<serde_json::Value>,
+    #[serde(rename = "fileSystem", default, skip_serializing_if = "Option::is_none")]
+    pub file_system: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FileServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFileStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "fileShare", default, skip_serializing_if = "Option::is_none")]
+    pub file_share: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub snapshot: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleCloudStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLinkedServiceTypeProperties {
+    #[serde(rename = "accessKeyId", default, skip_serializing_if = "Option::is_none")]
+    pub access_key_id: Option<serde_json::Value>,
+    #[serde(rename = "secretAccessKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_access_key: Option<SecretBase>,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OracleLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMySqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MySqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PostgreSqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SybaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sybase_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod sybase_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Db2LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2LinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    pub server: serde_json::Value,
+    pub database: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<db2_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "packageCollection", default, skip_serializing_if = "Option::is_none")]
+    pub package_collection: Option<serde_json::Value>,
+    #[serde(rename = "certificateCommonName", default, skip_serializing_if = "Option::is_none")]
+    pub certificate_common_name: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod db2_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: TeradataLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<teradata_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod teradata_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlLinkedServiceTypeProperties {
+    #[serde(rename = "mlEndpoint")]
+    pub ml_endpoint: serde_json::Value,
+    #[serde(rename = "apiKey")]
+    pub api_key: SecretBase,
+    #[serde(rename = "updateResourceEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub update_resource_endpoint: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlServiceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlServiceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlServiceLinkedServiceTypeProperties {
+    #[serde(rename = "subscriptionId")]
+    pub subscription_id: serde_json::Value,
+    #[serde(rename = "resourceGroupName")]
+    pub resource_group_name: serde_json::Value,
+    #[serde(rename = "mlWorkspaceName")]
+    pub ml_workspace_name: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OdbcLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: InformixLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MicrosoftAccessLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdfsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ODataLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<o_data_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "aadResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub aad_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "aadServicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub aad_service_principal_credential_type: Option<o_data_linked_service_type_properties::AadServicePrincipalCredentialType>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalEmbeddedCert", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_embedded_cert: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalEmbeddedCertPassword", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_embedded_cert_password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod o_data_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        Windows,
+        AadServicePrincipal,
+        ManagedServiceIdentity,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AadServicePrincipalCredentialType {
+        ServicePrincipalKey,
+        ServicePrincipalCert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: web_linked_service_type_properties::AuthenticationType,
+}
+pub mod web_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        ClientCertificate,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebAnonymousAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebBasicAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+    pub username: serde_json::Value,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebClientCertificateAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+    pub pfx: SecretBase,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CassandraLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<mongo_db_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "databaseName")]
+    pub database_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "authSource", default, skip_serializing_if = "Option::is_none")]
+    pub auth_source: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod mongo_db_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbAtlasLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbV2LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2LinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbMongoDbApiLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataLakeStoreLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLinkedServiceTypeProperties {
+    #[serde(rename = "dataLakeStoreUri")]
+    pub data_lake_store_uri: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<serde_json::Value>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<serde_json::Value>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBlobFsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Office365LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365LinkedServiceTypeProperties {
+    #[serde(rename = "office365TenantId")]
+    pub office365_tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalTenantId")]
+    pub service_principal_tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceLinkedServiceTypeProperties {
+    #[serde(rename = "environmentUrl", default, skip_serializing_if = "Option::is_none")]
+    pub environment_url: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "securityToken", default, skip_serializing_if = "Option::is_none")]
+    pub security_token: Option<SecretBase>,
+    #[serde(rename = "apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceServiceCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudLinkedServiceTypeProperties {
+    #[serde(rename = "environmentUrl", default, skip_serializing_if = "Option::is_none")]
+    pub environment_url: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "securityToken", default, skip_serializing_if = "Option::is_none")]
+    pub security_token: Option<SecretBase>,
+    #[serde(rename = "apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<serde_json::Value>,
+    #[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapCloudForCustomerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapEccLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccLinkedServiceTypeProperties {
+    pub url: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapOpenHubLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "systemNumber")]
+    pub system_number: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<serde_json::Value>,
+    #[serde(rename = "systemId", default, skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "messageServer", default, skip_serializing_if = "Option::is_none")]
+    pub message_server: Option<serde_json::Value>,
+    #[serde(rename = "messageServerService", default, skip_serializing_if = "Option::is_none")]
+    pub message_server_service: Option<serde_json::Value>,
+    #[serde(rename = "logonGroup", default, skip_serializing_if = "Option::is_none")]
+    pub logon_group: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestServiceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: RestServiceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestServiceLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: rest_service_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "aadResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub aad_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod rest_service_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Basic,
+        AadServicePrincipal,
+        ManagedServiceIdentity,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonS3LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3LinkedServiceTypeProperties {
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(rename = "accessKeyId", default, skip_serializing_if = "Option::is_none")]
+    pub access_key_id: Option<serde_json::Value>,
+    #[serde(rename = "secretAccessKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_access_key: Option<SecretBase>,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<serde_json::Value>,
+    #[serde(rename = "sessionToken", default, skip_serializing_if = "Option::is_none")]
+    pub session_token: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRedshiftLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomDataSourceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSearchLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HttpLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<http_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "embeddedCertData", default, skip_serializing_if = "Option::is_none")]
+    pub embedded_cert_data: Option<serde_json::Value>,
+    #[serde(rename = "certThumbprint", default, skip_serializing_if = "Option::is_none")]
+    pub cert_thumbprint: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+}
+pub mod http_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        Digest,
+        Windows,
+        ClientCertificate,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FtpServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<ftp_server_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+}
+pub mod ftp_server_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SftpServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sftp_server_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "privateKeyPath", default, skip_serializing_if = "Option::is_none")]
+    pub private_key_path: Option<serde_json::Value>,
+    #[serde(rename = "privateKeyContent", default, skip_serializing_if = "Option::is_none")]
+    pub private_key_content: Option<SecretBase>,
+    #[serde(rename = "passPhrase", default, skip_serializing_if = "Option::is_none")]
+    pub pass_phrase: Option<SecretBase>,
+    #[serde(rename = "skipHostKeyValidation", default, skip_serializing_if = "Option::is_none")]
+    pub skip_host_key_validation: Option<serde_json::Value>,
+    #[serde(rename = "hostKeyFingerprint", default, skip_serializing_if = "Option::is_none")]
+    pub host_key_fingerprint: Option<serde_json::Value>,
+}
+pub mod sftp_server_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        SshPublicKey,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapBwLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "systemNumber")]
+    pub system_number: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapHanaLinkedServiceProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaLinkedServiceProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    pub server: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sap_hana_linked_service_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod sap_hana_linked_service_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonMwsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "marketplaceID")]
+    pub marketplace_id: serde_json::Value,
+    #[serde(rename = "sellerID")]
+    pub seller_id: serde_json::Value,
+    #[serde(rename = "mwsAuthToken", default, skip_serializing_if = "Option::is_none")]
+    pub mws_auth_token: Option<SecretBase>,
+    #[serde(rename = "accessKeyId")]
+    pub access_key_id: serde_json::Value,
+    #[serde(rename = "secretKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_key: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzurePostgreSqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ConcurLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CouchbaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "credString", default, skip_serializing_if = "Option::is_none")]
+    pub cred_string: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DrillLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: EloquaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleBigQueryLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryLinkedServiceTypeProperties {
+    pub project: serde_json::Value,
+    #[serde(rename = "additionalProjects", default, skip_serializing_if = "Option::is_none")]
+    pub additional_projects: Option<serde_json::Value>,
+    #[serde(rename = "requestGoogleDriveScope", default, skip_serializing_if = "Option::is_none")]
+    pub request_google_drive_scope: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: google_big_query_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub email: Option<serde_json::Value>,
+    #[serde(rename = "keyFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub key_file_path: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod google_big_query_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        ServiceAuthentication,
+        UserAuthentication,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GreenplumLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HBaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: h_base_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod h_base_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Basic,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HiveLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serverType", default, skip_serializing_if = "Option::is_none")]
+    pub server_type: Option<hive_linked_service_type_properties::ServerType>,
+    #[serde(rename = "thriftTransportProtocol", default, skip_serializing_if = "Option::is_none")]
+    pub thrift_transport_protocol: Option<hive_linked_service_type_properties::ThriftTransportProtocol>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: hive_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "serviceDiscoveryMode", default, skip_serializing_if = "Option::is_none")]
+    pub service_discovery_mode: Option<serde_json::Value>,
+    #[serde(rename = "zooKeeperNameSpace", default, skip_serializing_if = "Option::is_none")]
+    pub zoo_keeper_name_space: Option<serde_json::Value>,
+    #[serde(rename = "useNativeQuery", default, skip_serializing_if = "Option::is_none")]
+    pub use_native_query: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod hive_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServerType {
+        HiveServer1,
+        HiveServer2,
+        HiveThriftServer,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ThriftTransportProtocol {
+        Binary,
+        #[serde(rename = "SASL")]
+        Sasl,
+        #[serde(rename = "HTTP ")]
+        Http,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Username,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HubspotLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotLinkedServiceTypeProperties {
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ImpalaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: impala_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod impala_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        #[serde(rename = "SASLUsername")]
+        SaslUsername,
+        UsernameAndPassword,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: JiraLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MagentoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MariaDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMariaDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MarketoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PaypalLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PhoenixLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: phoenix_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod phoenix_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PrestoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "serverVersion")]
+    pub server_version: serde_json::Value,
+    pub catalog: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: presto_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "timeZoneID", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod presto_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        #[serde(rename = "LDAP")]
+        Ldap,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: QuickBooksLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "companyId")]
+    pub company_id: serde_json::Value,
+    #[serde(rename = "consumerKey")]
+    pub consumer_key: serde_json::Value,
+    #[serde(rename = "consumerSecret")]
+    pub consumer_secret: SecretBase,
+    #[serde(rename = "accessToken")]
+    pub access_token: SecretBase,
+    #[serde(rename = "accessTokenSecret")]
+    pub access_token_secret: SecretBase,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ServiceNowLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: service_now_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod service_now_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        OAuth2,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ShopifyLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SparkLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    pub port: serde_json::Value,
+    #[serde(rename = "serverType", default, skip_serializing_if = "Option::is_none")]
+    pub server_type: Option<spark_linked_service_type_properties::ServerType>,
+    #[serde(rename = "thriftTransportProtocol", default, skip_serializing_if = "Option::is_none")]
+    pub thrift_transport_protocol: Option<spark_linked_service_type_properties::ThriftTransportProtocol>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: spark_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod spark_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServerType {
+        SharkServer,
+        SharkServer2,
+        SparkThriftServer,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ThriftTransportProtocol {
+        Binary,
+        #[serde(rename = "SASL")]
+        Sasl,
+        #[serde(rename = "HTTP ")]
+        Http,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Username,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SquareLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub host: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "redirectUri")]
+    pub redirect_uri: serde_json::Value,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: XeroLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub host: serde_json::Value,
+    #[serde(rename = "consumerKey", default, skip_serializing_if = "Option::is_none")]
+    pub consumer_key: Option<SecretBase>,
+    #[serde(rename = "privateKey", default, skip_serializing_if = "Option::is_none")]
+    pub private_key: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ZohoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: VerticaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: NetezzaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceMarketingCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightOnDemandLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightOnDemandLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightOnDemandLinkedServiceTypeProperties {
+    #[serde(rename = "clusterSize")]
+    pub cluster_size: serde_json::Value,
+    #[serde(rename = "timeToLive")]
+    pub time_to_live: serde_json::Value,
+    pub version: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(rename = "hostSubscriptionId")]
+    pub host_subscription_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "clusterResourceGroup")]
+    pub cluster_resource_group: serde_json::Value,
+    #[serde(rename = "clusterNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_name_prefix: Option<serde_json::Value>,
+    #[serde(rename = "clusterUserName", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_user_name: Option<serde_json::Value>,
+    #[serde(rename = "clusterPassword", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_password: Option<SecretBase>,
+    #[serde(rename = "clusterSshUserName", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_ssh_user_name: Option<serde_json::Value>,
+    #[serde(rename = "clusterSshPassword", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_ssh_password: Option<SecretBase>,
+    #[serde(rename = "additionalLinkedServiceNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_linked_service_names: Vec<LinkedServiceReference>,
+    #[serde(rename = "hcatalogLinkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub hcatalog_linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "clusterType", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_type: Option<serde_json::Value>,
+    #[serde(rename = "sparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub spark_version: Option<serde_json::Value>,
+    #[serde(rename = "coreConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub core_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hBaseConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub h_base_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hdfsConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub hdfs_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hiveConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub hive_configuration: Option<serde_json::Value>,
+    #[serde(rename = "mapReduceConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub map_reduce_configuration: Option<serde_json::Value>,
+    #[serde(rename = "oozieConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub oozie_configuration: Option<serde_json::Value>,
+    #[serde(rename = "stormConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub storm_configuration: Option<serde_json::Value>,
+    #[serde(rename = "yarnConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_configuration: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "headNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub head_node_size: Option<serde_json::Value>,
+    #[serde(rename = "dataNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub data_node_size: Option<serde_json::Value>,
+    #[serde(rename = "zookeeperNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub zookeeper_node_size: Option<serde_json::Value>,
+    #[serde(rename = "scriptActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub script_actions: Vec<ScriptAction>,
+    #[serde(rename = "virtualNetworkId", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_network_id: Option<serde_json::Value>,
+    #[serde(rename = "subnetName", default, skip_serializing_if = "Option::is_none")]
+    pub subnet_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScriptAction {
+    pub name: String,
+    pub uri: String,
+    pub roles: script_action::Roles,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<String>,
+}
+pub mod script_action {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Roles {
+        Headnode,
+        Workernode,
+        Zookeeper,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeAnalyticsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataLakeAnalyticsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeAnalyticsLinkedServiceTypeProperties {
+    #[serde(rename = "accountName")]
+    pub account_name: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<serde_json::Value>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<serde_json::Value>,
+    #[serde(rename = "dataLakeAnalyticsUri", default, skip_serializing_if = "Option::is_none")]
+    pub data_lake_analytics_uri: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDatabricksLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksLinkedServiceTypeProperties {
+    pub domain: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<serde_json::Value>,
+    #[serde(rename = "workspaceResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "existingClusterId", default, skip_serializing_if = "Option::is_none")]
+    pub existing_cluster_id: Option<serde_json::Value>,
+    #[serde(rename = "instancePoolId", default, skip_serializing_if = "Option::is_none")]
+    pub instance_pool_id: Option<serde_json::Value>,
+    #[serde(rename = "newClusterVersion", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_version: Option<serde_json::Value>,
+    #[serde(rename = "newClusterNumOfWorker", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_num_of_worker: Option<serde_json::Value>,
+    #[serde(rename = "newClusterNodeType", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_node_type: Option<serde_json::Value>,
+    #[serde(rename = "newClusterSparkConf", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_spark_conf: Option<serde_json::Value>,
+    #[serde(rename = "newClusterSparkEnvVars", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_spark_env_vars: Option<serde_json::Value>,
+    #[serde(rename = "newClusterCustomTags", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_custom_tags: Option<serde_json::Value>,
+    #[serde(rename = "newClusterLogDestination", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_log_destination: Option<serde_json::Value>,
+    #[serde(rename = "newClusterDriverNodeType", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_driver_node_type: Option<serde_json::Value>,
+    #[serde(rename = "newClusterInitScripts", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_init_scripts: Option<serde_json::Value>,
+    #[serde(rename = "newClusterEnableElasticDisk", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_enable_elastic_disk: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "policyId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_id: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDatabricksDetltaLakeLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDetltaLakeLinkedServiceTypeProperties {
+    pub domain: serde_json::Value,
+    #[serde(rename = "accessToken")]
+    pub access_token: SecretBase,
+    #[serde(rename = "clusterId", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ResponsysLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsAxLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "aadResourceId")]
+    pub aad_resource_id: serde_json::Value,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OracleServiceCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    pub username: serde_json::Value,
+    pub password: SecretBase,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleAdWordsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsLinkedServiceTypeProperties {
+    #[serde(rename = "clientCustomerID")]
+    pub client_customer_id: serde_json::Value,
+    #[serde(rename = "developerToken")]
+    pub developer_token: SecretBase,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: google_ad_words_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub email: Option<serde_json::Value>,
+    #[serde(rename = "keyFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub key_file_path: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod google_ad_words_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        ServiceAuthentication,
+        UserAuthentication,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapTableLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableLinkedServiceTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<serde_json::Value>,
+    #[serde(rename = "systemNumber", default, skip_serializing_if = "Option::is_none")]
+    pub system_number: Option<serde_json::Value>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<serde_json::Value>,
+    #[serde(rename = "systemId", default, skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "messageServer", default, skip_serializing_if = "Option::is_none")]
+    pub message_server: Option<serde_json::Value>,
+    #[serde(rename = "messageServerService", default, skip_serializing_if = "Option::is_none")]
+    pub message_server_service: Option<serde_json::Value>,
+    #[serde(rename = "sncMode", default, skip_serializing_if = "Option::is_none")]
+    pub snc_mode: Option<serde_json::Value>,
+    #[serde(rename = "sncMyName", default, skip_serializing_if = "Option::is_none")]
+    pub snc_my_name: Option<serde_json::Value>,
+    #[serde(rename = "sncPartnerName", default, skip_serializing_if = "Option::is_none")]
+    pub snc_partner_name: Option<serde_json::Value>,
+    #[serde(rename = "sncLibraryPath", default, skip_serializing_if = "Option::is_none")]
+    pub snc_library_path: Option<serde_json::Value>,
+    #[serde(rename = "sncQop", default, skip_serializing_if = "Option::is_none")]
+    pub snc_qop: Option<serde_json::Value>,
+    #[serde(rename = "logonGroup", default, skip_serializing_if = "Option::is_none")]
+    pub logon_group: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    pub database: serde_json::Value,
+    pub tenant: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFunctionLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionLinkedServiceTypeProperties {
+    #[serde(rename = "functionAppUrl")]
+    pub function_app_url: serde_json::Value,
+    #[serde(rename = "functionKey", default, skip_serializing_if = "Option::is_none")]
+    pub function_key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SnowflakeLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SharePointOnlineListLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListLinkedServiceTypeProperties {
+    #[serde(rename = "siteUrl")]
+    pub site_url: serde_json::Value,
+    #[serde(rename = "tenantId")]
+    pub tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScript {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<sql_script::Type>,
+    pub content: SqlScriptContent,
+}
+pub mod sql_script {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlQuery,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptContent {
+    pub query: String,
+    #[serde(rename = "currentConnection")]
+    pub current_connection: SqlConnection,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<SqlScriptMetadata>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptMetadata {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlConnection {
+    #[serde(rename = "type")]
+    pub type_: sql_connection::Type,
+    pub name: String,
+}
+pub mod sql_connection {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlOnDemand,
+        SqlPool,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinition {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "targetBigDataPool")]
+    pub target_big_data_pool: BigDataPoolReference,
+    #[serde(rename = "requiredSparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub required_spark_version: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    #[serde(rename = "jobProperties")]
+    pub job_properties: SparkJobProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    pub file: String,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(rename = "driverMemory")]
+    pub driver_memory: String,
+    #[serde(rename = "driverCores")]
+    pub driver_cores: i64,
+    #[serde(rename = "executorMemory")]
+    pub executor_memory: String,
+    #[serde(rename = "executorCores")]
+    pub executor_cores: i64,
+    #[serde(rename = "numExecutors")]
+    pub num_executors: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Notebook {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "bigDataPool", default, skip_serializing_if = "Option::is_none")]
+    pub big_data_pool: Option<BigDataPoolReference>,
+    #[serde(rename = "sessionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub session_properties: Option<NotebookSessionProperties>,
+    pub metadata: NotebookMetadata,
+    pub nbformat: i64,
+    pub nbformat_minor: i64,
+    pub cells: Vec<NotebookCell>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolReference {
+    #[serde(rename = "type")]
+    pub type_: big_data_pool_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod big_data_pool_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        BigDataPoolReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookMetadata {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kernelspec: Option<NotebookKernelSpec>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language_info: Option<NotebookLanguageInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookKernelSpec {
+    pub name: String,
+    pub display_name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookLanguageInfo {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub codemirror_mode: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookCell {
+    pub cell_type: String,
+    pub metadata: serde_json::Value,
+    pub source: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub attachments: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<NotebookCellOutputItem>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookSessionProperties {
+    #[serde(rename = "driverMemory")]
+    pub driver_memory: String,
+    #[serde(rename = "driverCores")]
+    pub driver_cores: i64,
+    #[serde(rename = "executorMemory")]
+    pub executor_memory: String,
+    #[serde(rename = "executorCores")]
+    pub executor_cores: i64,
+    #[serde(rename = "numExecutors")]
+    pub num_executors: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookCellOutputItem {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub execution_count: Option<i64>,
+    pub output_type: notebook_cell_output_item::OutputType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub text: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+}
+pub mod notebook_cell_output_item {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OutputType {
+        #[serde(rename = "execute_result")]
+        ExecuteResult,
+        #[serde(rename = "display_data")]
+        DisplayData,
+        #[serde(rename = "stream")]
+        Stream,
+        #[serde(rename = "error")]
+        Error,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlow {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<data_flow::Folder>,
+}
+pub mod data_flow {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MappingDataFlow {
+    #[serde(flatten)]
+    pub data_flow: DataFlow,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MappingDataFlowTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MappingDataFlowTypeProperties {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sources: Vec<DataFlowSource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sinks: Vec<DataFlowSink>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub transformations: Vec<Transformation>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub script: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Transformation {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSource {
+    #[serde(flatten)]
+    pub transformation: Transformation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<DatasetReference>,
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "schemaLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub schema_linked_service: Option<LinkedServiceReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSink {
+    #[serde(flatten)]
+    pub transformation: Transformation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<DatasetReference>,
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "schemaLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub schema_linked_service: Option<LinkedServiceReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OperationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<CloudErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryListResponse {
+    pub value: Vec<LibraryResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResourceInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "recordId", default, skip_serializing_if = "Option::is_none")]
+    pub record_id: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub created: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub changed: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "operationId", default, skip_serializing_if = "Option::is_none")]
+    pub operation_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: LibraryResourceProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResourceProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "containerName", default, skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+    #[serde(rename = "uploadedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub uploaded_timestamp: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<String>,
+    #[serde(rename = "creatorId", default, skip_serializing_if = "Option::is_none")]
+    pub creator_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubClientSecret {
+    #[serde(rename = "byoaSecretAkvUrl", default, skip_serializing_if = "Option::is_none")]
+    pub byoa_secret_akv_url: Option<String>,
+    #[serde(rename = "byoaSecretName", default, skip_serializing_if = "Option::is_none")]
+    pub byoa_secret_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubAccessTokenRequest {
+    #[serde(rename = "gitHubClientId")]
+    pub git_hub_client_id: String,
+    #[serde(rename = "gitHubClientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub git_hub_client_secret: Option<GitHubClientSecret>,
+    #[serde(rename = "gitHubAccessCode")]
+    pub git_hub_access_code: String,
+    #[serde(rename = "gitHubAccessTokenBaseUrl")]
+    pub git_hub_access_token_base_url: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubAccessTokenResponse {
+    #[serde(rename = "gitHubAccessToken", default, skip_serializing_if = "Option::is_none")]
+    pub git_hub_access_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJob {
+    #[serde(rename = "livyInfo", default, skip_serializing_if = "Option::is_none")]
+    pub livy_info: Option<SparkBatchJobState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "workspaceName", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_name: Option<String>,
+    #[serde(rename = "sparkPoolName", default, skip_serializing_if = "Option::is_none")]
+    pub spark_pool_name: Option<String>,
+    #[serde(rename = "submitterName", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_name: Option<String>,
+    #[serde(rename = "submitterId", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<spark_batch_job::JobType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<spark_batch_job::Result>,
+    #[serde(rename = "schedulerInfo", default, skip_serializing_if = "Option::is_none")]
+    pub scheduler_info: Option<SparkScheduler>,
+    #[serde(rename = "pluginInfo", default, skip_serializing_if = "Option::is_none")]
+    pub plugin_info: Option<SparkServicePlugin>,
+    #[serde(rename = "errorInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_info: Vec<SparkServiceError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub id: i32,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appInfo", default, skip_serializing_if = "Option::is_none")]
+    pub app_info: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub log: Vec<String>,
+}
+pub mod spark_batch_job {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum JobType {
+        SparkBatch,
+        SparkSession,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        Uncertain,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobState {
+    #[serde(rename = "notStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub not_started_at: Option<String>,
+    #[serde(rename = "startingAt", default, skip_serializing_if = "Option::is_none")]
+    pub starting_at: Option<String>,
+    #[serde(rename = "runningAt", default, skip_serializing_if = "Option::is_none")]
+    pub running_at: Option<String>,
+    #[serde(rename = "deadAt", default, skip_serializing_if = "Option::is_none")]
+    pub dead_at: Option<String>,
+    #[serde(rename = "successAt", default, skip_serializing_if = "Option::is_none")]
+    pub success_at: Option<String>,
+    #[serde(rename = "killedAt", default, skip_serializing_if = "Option::is_none")]
+    pub killed_at: Option<String>,
+    #[serde(rename = "recoveringAt", default, skip_serializing_if = "Option::is_none")]
+    pub recovering_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+    #[serde(rename = "jobCreationRequest", default, skip_serializing_if = "Option::is_none")]
+    pub job_creation_request: Option<SparkRequest>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub file: Option<String>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkScheduler {
+    #[serde(rename = "submittedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submitted_at: Option<String>,
+    #[serde(rename = "scheduledAt", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_at: Option<String>,
+    #[serde(rename = "endedAt", default, skip_serializing_if = "Option::is_none")]
+    pub ended_at: Option<String>,
+    #[serde(rename = "cancellationRequestedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_requested_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_scheduler::CurrentState>,
+}
+pub mod spark_scheduler {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Queued,
+        Scheduled,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServicePlugin {
+    #[serde(rename = "preparationStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub preparation_started_at: Option<String>,
+    #[serde(rename = "resourceAcquisitionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub resource_acquisition_started_at: Option<String>,
+    #[serde(rename = "submissionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submission_started_at: Option<String>,
+    #[serde(rename = "monitoringStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub monitoring_started_at: Option<String>,
+    #[serde(rename = "cleanupStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cleanup_started_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_service_plugin::CurrentState>,
+}
+pub mod spark_service_plugin {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Preparation,
+        ResourceAcquisition,
+        Queued,
+        Submission,
+        Monitoring,
+        Cleanup,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServiceError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<spark_service_error::Source>,
+}
+pub mod spark_service_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Source {
+        System,
+        User,
+        Unknown,
+        Dependency,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureEntityResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Resource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntime {
+    #[serde(rename = "type")]
+    pub type_: IntegrationRuntimeType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum IntegrationRuntimeType {
+    Managed,
+    SelfHosted,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Workspace {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<WorkspaceProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<ManagedIdentity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceProperties {
+    #[serde(rename = "defaultDataLakeStorage", default, skip_serializing_if = "Option::is_none")]
+    pub default_data_lake_storage: Option<DataLakeStorageAccountDetails>,
+    #[serde(rename = "sqlAdministratorLoginPassword", default, skip_serializing_if = "Option::is_none")]
+    pub sql_administrator_login_password: Option<String>,
+    #[serde(rename = "managedResourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub managed_resource_group_name: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "sqlAdministratorLogin", default, skip_serializing_if = "Option::is_none")]
+    pub sql_administrator_login: Option<String>,
+    #[serde(rename = "virtualNetworkProfile", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_network_profile: Option<VirtualNetworkProfile>,
+    #[serde(rename = "connectivityEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub connectivity_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "managedVirtualNetwork", default, skip_serializing_if = "Option::is_none")]
+    pub managed_virtual_network: Option<String>,
+    #[serde(rename = "privateEndpointConnections", default, skip_serializing_if = "Vec::is_empty")]
+    pub private_endpoint_connections: Vec<PrivateEndpointConnection>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encryption: Option<EncryptionDetails>,
+    #[serde(rename = "workspaceUID", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_uid: Option<String>,
+    #[serde(rename = "extraProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extra_properties: Option<serde_json::Value>,
+    #[serde(rename = "managedVirtualNetworkSettings", default, skip_serializing_if = "Option::is_none")]
+    pub managed_virtual_network_settings: Option<ManagedVirtualNetworkSettings>,
+    #[serde(rename = "workspaceRepositoryConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_repository_configuration: Option<WorkspaceRepositoryConfiguration>,
+    #[serde(rename = "purviewConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub purview_configuration: Option<PurviewConfiguration>,
+    #[serde(rename = "adlaResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub adla_resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeStorageAccountDetails {
+    #[serde(rename = "accountUrl", default, skip_serializing_if = "Option::is_none")]
+    pub account_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filesystem: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualNetworkProfile {
+    #[serde(rename = "computeSubnetId", default, skip_serializing_if = "Option::is_none")]
+    pub compute_subnet_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpointConnection {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<PrivateEndpointConnectionProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpointConnectionProperties {
+    #[serde(rename = "privateEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub private_endpoint: Option<PrivateEndpoint>,
+    #[serde(rename = "privateLinkServiceConnectionState", default, skip_serializing_if = "Option::is_none")]
+    pub private_link_service_connection_state: Option<PrivateLinkServiceConnectionState>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpoint {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateLinkServiceConnectionState {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "actionsRequired", default, skip_serializing_if = "Option::is_none")]
+    pub actions_required: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProxyResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionDetails {
+    #[serde(rename = "doubleEncryptionEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub double_encryption_enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cmk: Option<CustomerManagedKeyDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomerManagedKeyDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<WorkspaceKeyDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceKeyDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "keyVaultUrl", default, skip_serializing_if = "Option::is_none")]
+    pub key_vault_url: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedVirtualNetworkSettings {
+    #[serde(rename = "preventDataExfiltration", default, skip_serializing_if = "Option::is_none")]
+    pub prevent_data_exfiltration: Option<bool>,
+    #[serde(rename = "linkedAccessCheckOnTargetResource", default, skip_serializing_if = "Option::is_none")]
+    pub linked_access_check_on_target_resource: Option<bool>,
+    #[serde(rename = "allowedAadTenantIdsForLinking", default, skip_serializing_if = "Vec::is_empty")]
+    pub allowed_aad_tenant_ids_for_linking: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceRepositoryConfiguration {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<String>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<String>,
+    #[serde(rename = "projectName", default, skip_serializing_if = "Option::is_none")]
+    pub project_name: Option<String>,
+    #[serde(rename = "repositoryName", default, skip_serializing_if = "Option::is_none")]
+    pub repository_name: Option<String>,
+    #[serde(rename = "collaborationBranch", default, skip_serializing_if = "Option::is_none")]
+    pub collaboration_branch: Option<String>,
+    #[serde(rename = "rootFolder", default, skip_serializing_if = "Option::is_none")]
+    pub root_folder: Option<String>,
+    #[serde(rename = "lastCommitId", default, skip_serializing_if = "Option::is_none")]
+    pub last_commit_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<GitHubClientSecret>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PurviewConfiguration {
+    #[serde(rename = "purviewResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub purview_resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedIdentity {
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<managed_identity::Type>,
+}
+pub mod managed_identity {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        None,
+        SystemAssigned,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TrackedResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub location: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorResponse>,
+    #[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_info: Vec<ErrorAdditionalInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorAdditionalInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolInfoListResult {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<SqlPool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPool {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<Sku>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<SqlPoolResourceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Sku {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tier: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub capacity: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolResourceProperties {
+    #[serde(rename = "maxSizeBytes", default, skip_serializing_if = "Option::is_none")]
+    pub max_size_bytes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collation: Option<String>,
+    #[serde(rename = "sourceDatabaseId", default, skip_serializing_if = "Option::is_none")]
+    pub source_database_id: Option<String>,
+    #[serde(rename = "recoverableDatabaseId", default, skip_serializing_if = "Option::is_none")]
+    pub recoverable_database_id: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "restorePointInTime", default, skip_serializing_if = "Option::is_none")]
+    pub restore_point_in_time: Option<String>,
+    #[serde(rename = "createMode", default, skip_serializing_if = "Option::is_none")]
+    pub create_mode: Option<sql_pool_resource_properties::CreateMode>,
+    #[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
+    pub creation_date: Option<String>,
+}
+pub mod sql_pool_resource_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CreateMode {
+        Default,
+        PointInTimeRestore,
+        Recovery,
+        Restore,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceInfoListResult {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<BigDataPoolResourceInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceInfo {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<BigDataPoolResourceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceProperties {
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "autoScale", default, skip_serializing_if = "Option::is_none")]
+    pub auto_scale: Option<AutoScaleProperties>,
+    #[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
+    pub creation_date: Option<String>,
+    #[serde(rename = "autoPause", default, skip_serializing_if = "Option::is_none")]
+    pub auto_pause: Option<AutoPauseProperties>,
+    #[serde(rename = "isComputeIsolationEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_compute_isolation_enabled: Option<bool>,
+    #[serde(rename = "sessionLevelPackagesEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub session_level_packages_enabled: Option<bool>,
+    #[serde(rename = "cacheSize", default, skip_serializing_if = "Option::is_none")]
+    pub cache_size: Option<i32>,
+    #[serde(rename = "dynamicExecutorAllocation", default, skip_serializing_if = "Option::is_none")]
+    pub dynamic_executor_allocation: Option<DynamicExecutorAllocation>,
+    #[serde(rename = "sparkEventsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub spark_events_folder: Option<String>,
+    #[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub node_count: Option<i32>,
+    #[serde(rename = "libraryRequirements", default, skip_serializing_if = "Option::is_none")]
+    pub library_requirements: Option<LibraryRequirements>,
+    #[serde(rename = "customLibraries", default, skip_serializing_if = "Vec::is_empty")]
+    pub custom_libraries: Vec<LibraryInfo>,
+    #[serde(rename = "sparkConfigProperties", default, skip_serializing_if = "Option::is_none")]
+    pub spark_config_properties: Option<LibraryRequirements>,
+    #[serde(rename = "sparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub spark_version: Option<String>,
+    #[serde(rename = "defaultSparkLogFolder", default, skip_serializing_if = "Option::is_none")]
+    pub default_spark_log_folder: Option<String>,
+    #[serde(rename = "nodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub node_size: Option<big_data_pool_resource_properties::NodeSize>,
+    #[serde(rename = "nodeSizeFamily", default, skip_serializing_if = "Option::is_none")]
+    pub node_size_family: Option<big_data_pool_resource_properties::NodeSizeFamily>,
+    #[serde(rename = "lastSucceededTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub last_succeeded_timestamp: Option<String>,
+}
+pub mod big_data_pool_resource_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum NodeSize {
+        None,
+        Small,
+        Medium,
+        Large,
+        XLarge,
+        #[serde(rename = "XXLarge")]
+        XxLarge,
+        #[serde(rename = "XXXLarge")]
+        XxxLarge,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum NodeSizeFamily {
+        None,
+        MemoryOptimized,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AutoScaleProperties {
+    #[serde(rename = "minNodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub min_node_count: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(rename = "maxNodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub max_node_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AutoPauseProperties {
+    #[serde(rename = "delayInMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub delay_in_minutes: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicExecutorAllocation {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryRequirements {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filename: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "containerName", default, skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+    #[serde(rename = "uploadedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub uploaded_timestamp: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<String>,
+    #[serde(rename = "creatorId", default, skip_serializing_if = "Option::is_none")]
+    pub creator_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeListResponse {
+    pub value: Vec<IntegrationRuntimeResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: IntegrationRuntime,
+}
diff --git a/services/svc/synapse/src/package_artifacts_2019_06_01_preview/operations.rs b/services/svc/synapse/src/package_artifacts_2019_06_01_preview/operations.rs
new file mode 100644
index 0000000000..6793efc80a
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2019_06_01_preview/operations.rs
@@ -0,0 +1,5163 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod linked_service {
+    use crate::models::*;
+    pub async fn get_linked_services_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<LinkedServiceListResponse, get_linked_services_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_linked_services_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_linked_services_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_linked_services_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_linked_services_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_services_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_services_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_linked_services_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_linked_services_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<LinkedServiceResource, get_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(get_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_linked_service::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        if_match: Option<&str>,
+        linked_service: &LinkedServiceResource,
+    ) -> std::result::Result<create_or_update_linked_service::Response, create_or_update_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(linked_service).map_err(create_or_update_linked_service::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_linked_service::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_linked_service::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(LinkedServiceResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+    ) -> std::result::Result<delete_linked_service::Response, delete_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_linked_service::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_linked_service::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_linked_service::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_linked_service::Response, rename_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}/rename", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_linked_service::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_linked_service::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_linked_service::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod dataset {
+    use crate::models::*;
+    pub async fn get_datasets_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<DatasetListResponse, get_datasets_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_datasets_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_datasets_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_datasets_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_datasets_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_datasets_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_datasets_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_datasets_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_datasets_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<DatasetResource, get_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(get_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_dataset::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        if_match: Option<&str>,
+        dataset: &DatasetResource,
+    ) -> std::result::Result<create_or_update_dataset::Response, create_or_update_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(dataset).map_err(create_or_update_dataset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_dataset::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_dataset::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DatasetResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+    ) -> std::result::Result<delete_dataset::Response, delete_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_dataset::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_dataset::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_dataset::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_dataset::Response, rename_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}/rename", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_dataset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_dataset::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_dataset::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| rename_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline {
+    use crate::models::*;
+    pub async fn get_pipelines_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<PipelineListResponse, get_pipelines_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_pipelines_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipelines_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_pipelines_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipelines_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipelines_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipelines_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipelines_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipelines_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<PipelineResource, get_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(get_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_pipeline::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        if_match: Option<&str>,
+        pipeline: &PipelineResource,
+    ) -> std::result::Result<create_or_update_pipeline::Response, create_or_update_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(pipeline).map_err(create_or_update_pipeline::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_pipeline::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_pipeline::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(PipelineResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+    ) -> std::result::Result<delete_pipeline::Response, delete_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_pipeline::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_pipeline::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_pipeline::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_pipeline::Response, rename_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}/rename", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_pipeline::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_pipeline::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_pipeline::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        reference_pipeline_run_id: Option<&str>,
+        is_recovery: Option<bool>,
+        start_activity_name: Option<&str>,
+        parameters: Option<&ParameterValueSpecification>,
+    ) -> std::result::Result<CreateRunResponse, create_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}/createRun", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(create_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(reference_pipeline_run_id) = reference_pipeline_run_id {
+            url.query_pairs_mut()
+                .append_pair("referencePipelineRunId", reference_pipeline_run_id);
+        }
+        if let Some(is_recovery) = is_recovery {
+            url.query_pairs_mut().append_pair("isRecovery", is_recovery.to_string().as_str());
+        }
+        if let Some(start_activity_name) = start_activity_name {
+            url.query_pairs_mut().append_pair("startActivityName", start_activity_name);
+        }
+        let req_body = if let Some(parameters) = parameters {
+            azure_core::to_json(parameters).map_err(create_pipeline_run::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: CreateRunResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline_run {
+    use crate::models::*;
+    pub async fn query_pipeline_runs_by_workspace(
+        operation_config: &crate::OperationConfig,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<PipelineRunsQueryResponse, query_pipeline_runs_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryPipelineRuns", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_pipeline_runs_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_pipeline_runs_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_pipeline_runs_by_workspace::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_pipeline_runs_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_pipeline_runs_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_pipeline_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_pipeline_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_pipeline_runs_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_pipeline_runs_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        run_id: &str,
+    ) -> std::result::Result<PipelineRun, get_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelineruns/{}", operation_config.base_path(), run_id);
+        let mut url = url::Url::parse(url_str).map_err(get_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineRun = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_activity_runs(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        run_id: &str,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<ActivityRunsQueryResponse, query_activity_runs::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/pipelines/{}/pipelineruns/{}/queryActivityruns",
+            operation_config.base_path(),
+            pipeline_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(query_activity_runs::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_activity_runs::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_activity_runs::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query_activity_runs::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_activity_runs::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ActivityRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_activity_runs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_activity_runs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_activity_runs::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_activity_runs {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        run_id: &str,
+        is_recursive: Option<bool>,
+    ) -> std::result::Result<(), cancel_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelineruns/{}/cancel", operation_config.base_path(), run_id);
+        let mut url = url::Url::parse(url_str).map_err(cancel_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(is_recursive) = is_recursive {
+            url.query_pairs_mut().append_pair("isRecursive", is_recursive.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod trigger {
+    use crate::models::*;
+    pub async fn get_triggers_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<TriggerListResponse, get_triggers_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_triggers_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_triggers_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_triggers_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_triggers_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_triggers_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_triggers_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_triggers_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_triggers_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<TriggerResource, get_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(get_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_trigger::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        if_match: Option<&str>,
+        trigger: &TriggerResource,
+    ) -> std::result::Result<create_or_update_trigger::Response, create_or_update_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(trigger).map_err(create_or_update_trigger::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_trigger::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_trigger::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<delete_trigger::Response, delete_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_trigger::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_trigger::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_trigger::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn subscribe_trigger_to_events(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<subscribe_trigger_to_events::Response, subscribe_trigger_to_events::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/subscribeToEvents", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(subscribe_trigger_to_events::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(subscribe_trigger_to_events::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(subscribe_trigger_to_events::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(subscribe_trigger_to_events::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| subscribe_trigger_to_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(subscribe_trigger_to_events::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(subscribe_trigger_to_events::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| subscribe_trigger_to_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(subscribe_trigger_to_events::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod subscribe_trigger_to_events {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerSubscriptionOperationStatus),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_event_subscription_status(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<TriggerSubscriptionOperationStatus, get_event_subscription_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/getEventSubscriptionStatus",
+            operation_config.base_path(),
+            trigger_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_event_subscription_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_event_subscription_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_event_subscription_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_event_subscription_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_subscription_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_subscription_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_event_subscription_status::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_event_subscription_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn unsubscribe_trigger_from_events(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<unsubscribe_trigger_from_events::Response, unsubscribe_trigger_from_events::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/unsubscribeFromEvents", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(unsubscribe_trigger_from_events::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(unsubscribe_trigger_from_events::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(unsubscribe_trigger_from_events::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(unsubscribe_trigger_from_events::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| unsubscribe_trigger_from_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(unsubscribe_trigger_from_events::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(unsubscribe_trigger_from_events::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| unsubscribe_trigger_from_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(unsubscribe_trigger_from_events::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod unsubscribe_trigger_from_events {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerSubscriptionOperationStatus),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn start_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<(), start_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/start", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(start_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(start_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(start_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(start_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| start_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(start_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod start_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn stop_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<(), stop_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/stop", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(stop_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(stop_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(stop_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(stop_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| stop_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(stop_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod stop_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod trigger_run {
+    use crate::models::*;
+    pub async fn rerun_trigger_instance(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<(), rerun_trigger_instance::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/triggerRuns/{}/rerun",
+            operation_config.base_path(),
+            trigger_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(rerun_trigger_instance::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rerun_trigger_instance::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rerun_trigger_instance::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rerun_trigger_instance::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rerun_trigger_instance::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rerun_trigger_instance::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rerun_trigger_instance {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_trigger_instance(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<(), cancel_trigger_instance::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/triggerRuns/{}/cancel",
+            operation_config.base_path(),
+            trigger_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_trigger_instance::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_trigger_instance::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(cancel_trigger_instance::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_trigger_instance::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_trigger_instance::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_trigger_instance::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_trigger_instance {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_trigger_runs_by_workspace(
+        operation_config: &crate::OperationConfig,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<TriggerRunsQueryResponse, query_trigger_runs_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryTriggerRuns", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_trigger_runs_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_trigger_runs_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_trigger_runs_by_workspace::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_trigger_runs_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_trigger_runs_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_trigger_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_trigger_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_trigger_runs_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_trigger_runs_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_flow {
+    use crate::models::*;
+    pub async fn get_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<DataFlowResource, get_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(get_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        if_match: Option<&str>,
+        data_flow: &DataFlowResource,
+    ) -> std::result::Result<create_or_update_data_flow::Response, create_or_update_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(data_flow).map_err(create_or_update_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_data_flow::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_data_flow::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DataFlowResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+    ) -> std::result::Result<delete_data_flow::Response, delete_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_data_flow::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_data_flow::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_data_flow::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_data_flow::Response, rename_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}/rename", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_data_flow::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_data_flow::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_data_flows_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<DataFlowListResponse, get_data_flows_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_data_flows_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_data_flows_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_data_flows_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_data_flows_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_data_flows_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_data_flows_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_data_flows_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_data_flows_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_flow_debug_session {
+    use crate::models::*;
+    pub async fn create_data_flow_debug_session(
+        operation_config: &crate::OperationConfig,
+        request: &CreateDataFlowDebugSessionRequest,
+    ) -> std::result::Result<create_data_flow_debug_session::Response, create_data_flow_debug_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/createDataFlowDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(create_data_flow_debug_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_data_flow_debug_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(create_data_flow_debug_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_data_flow_debug_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_data_flow_debug_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(create_data_flow_debug_session::Response::Accepted202),
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: CreateDataFlowDebugSessionResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_data_flow_debug_session::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_data_flow_debug_session::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_data_flow_debug_session {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            Ok200(CreateDataFlowDebugSessionResponse),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_data_flow_debug_sessions_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<QueryDataFlowDebugSessionsResponse, query_data_flow_debug_sessions_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryDataFlowDebugSessions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_data_flow_debug_sessions_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_data_flow_debug_sessions_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_data_flow_debug_sessions_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_data_flow_debug_sessions_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryDataFlowDebugSessionsResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_data_flow_debug_sessions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_data_flow_debug_sessions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_data_flow_debug_sessions_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_data_flow_debug_sessions_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_data_flow(
+        operation_config: &crate::OperationConfig,
+        request: &DataFlowDebugPackage,
+    ) -> std::result::Result<AddDataFlowToDebugSessionResponse, add_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/addDataFlowToDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(add_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(add_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AddDataFlowToDebugSessionResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_data_flow_debug_session(
+        operation_config: &crate::OperationConfig,
+        request: &DeleteDataFlowDebugSessionRequest,
+    ) -> std::result::Result<(), delete_data_flow_debug_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deleteDataFlowDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(delete_data_flow_debug_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_data_flow_debug_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(delete_data_flow_debug_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_data_flow_debug_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_data_flow_debug_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_data_flow_debug_session::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_data_flow_debug_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_command(
+        operation_config: &crate::OperationConfig,
+        request: &DataFlowDebugCommandRequest,
+    ) -> std::result::Result<execute_command::Response, execute_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/executeDataFlowDebugCommand", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(execute_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(execute_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(execute_command::Response::Accepted202),
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowDebugCommandResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_command::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_command::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_command {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            Ok200(DataFlowDebugCommandResponse),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod sql_script {
+    use crate::models::*;
+    pub async fn get_sql_scripts_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SqlScriptsListResponse, get_sql_scripts_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_scripts_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_scripts_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_sql_scripts_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_scripts_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_scripts_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_scripts_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_sql_scripts_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_sql_scripts_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SqlScriptResource, get_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_sql_script::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        if_match: Option<&str>,
+        sql_script: &SqlScriptResource,
+    ) -> std::result::Result<create_or_update_sql_script::Response, create_or_update_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(sql_script).map_err(create_or_update_sql_script::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_sql_script::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_sql_script::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SqlScriptResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+    ) -> std::result::Result<delete_sql_script::Response, delete_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_sql_script::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_sql_script::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_sql_script::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_sql_script::Response, rename_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}/rename", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_sql_script::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_sql_script::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_sql_script::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod spark_job_definition {
+    use crate::models::*;
+    pub async fn get_spark_job_definitions_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SparkJobDefinitionsListResponse, get_spark_job_definitions_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_definitions_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_definitions_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_job_definitions_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_definitions_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definitions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definitions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_job_definitions_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_definitions_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SparkJobDefinitionResource, get_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_spark_job_definition::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        if_match: Option<&str>,
+        spark_job_definition: &SparkJobDefinitionResource,
+    ) -> std::result::Result<create_or_update_spark_job_definition::Response, create_or_update_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(spark_job_definition).map_err(create_or_update_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_spark_job_definition::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SparkJobDefinitionResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+    ) -> std::result::Result<delete_spark_job_definition::Response, delete_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_spark_job_definition::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_spark_job_definition::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_spark_job_definition::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+    ) -> std::result::Result<execute_spark_job_definition::Response, execute_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkJobDefinitions/{}/execute",
+            operation_config.base_path(),
+            spark_job_definition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(execute_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(execute_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_spark_job_definition::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202(SparkBatchJob),
+            Ok200(SparkBatchJob),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_spark_job_definition::Response, rename_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkJobDefinitions/{}/rename",
+            operation_config.base_path(),
+            spark_job_definition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(rename_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_spark_job_definition::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_spark_job_definition::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn debug_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_azure_resource: &SparkJobDefinitionResource,
+    ) -> std::result::Result<debug_spark_job_definition::Response, debug_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/debugSparkJobDefinition", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(debug_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(debug_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body =
+            azure_core::to_json(spark_job_definition_azure_resource).map_err(debug_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(debug_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(debug_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(debug_spark_job_definition::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(debug_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(debug_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod debug_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202(SparkBatchJob),
+            Ok200(SparkBatchJob),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod notebook {
+    use crate::models::*;
+    pub async fn get_notebooks_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<NotebookListResponse, get_notebooks_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_notebooks_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebooks_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_notebooks_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebooks_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebooks_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebooks_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebooks_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebooks_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_notebook_summary_by_work_space(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<NotebookListResponse, get_notebook_summary_by_work_space::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/summary", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_notebook_summary_by_work_space::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebook_summary_by_work_space::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_notebook_summary_by_work_space::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebook_summary_by_work_space::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebook_summary_by_work_space::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebook_summary_by_work_space::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebook_summary_by_work_space::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebook_summary_by_work_space {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<NotebookResource, get_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(get_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_notebook::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        if_match: Option<&str>,
+        notebook: &NotebookResource,
+    ) -> std::result::Result<create_or_update_notebook::Response, create_or_update_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(notebook).map_err(create_or_update_notebook::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_notebook::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_notebook::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(NotebookResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+    ) -> std::result::Result<delete_notebook::Response, delete_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_notebook::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_notebook::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_notebook::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_notebook::Response, rename_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}/rename", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_notebook::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_notebook::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_notebook::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod workspace {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig) -> std::result::Result<Workspace, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/workspace", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Workspace =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod sql_pools {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<SqlPoolInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlPools", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlPoolInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, sql_pool_name: &str) -> std::result::Result<SqlPool, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlPools/{}", operation_config.base_path(), sql_pool_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlPool =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod big_data_pools {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<BigDataPoolResourceInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/bigDataPools", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BigDataPoolResourceInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        big_data_pool_name: &str,
+    ) -> std::result::Result<BigDataPoolResourceInfo, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/bigDataPools/{}", operation_config.base_path(), big_data_pool_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BigDataPoolResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod integration_runtimes {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<IntegrationRuntimeListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/integrationRuntimes", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IntegrationRuntimeListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        integration_runtime_name: &str,
+    ) -> std::result::Result<IntegrationRuntimeResource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/integrationRuntimes/{}", operation_config.base_path(), integration_runtime_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IntegrationRuntimeResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod library {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<LibraryListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn flush(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<flush::Response, flush::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}/flush", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(flush::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(flush::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(flush::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(flush::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(flush::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| flush::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(flush::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| flush::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(flush::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod flush {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_operation_result(
+        operation_config: &crate::OperationConfig,
+        operation_id: &str,
+    ) -> std::result::Result<get_operation_result::Response, get_operation_result::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraryOperationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get_operation_result::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_operation_result::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_operation_result::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_operation_result::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(get_operation_result::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: OperationResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(get_operation_result::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_operation_result::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_operation_result {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(LibraryResource),
+            Accepted202(OperationResult),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, library_name: &str) -> std::result::Result<LibraryResource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<create::Response, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(create::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::CONFLICT => Err(delete::Error::Conflict409 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Conflict409 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod workspace_git_repo_management {
+    use crate::models::*;
+    pub async fn get_git_hub_access_token(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+        git_hub_access_token_request: &GitHubAccessTokenRequest,
+    ) -> std::result::Result<GitHubAccessTokenResponse, get_git_hub_access_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/getGitHubAccessToken", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_git_hub_access_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_git_hub_access_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        let req_body = azure_core::to_json(git_hub_access_token_request).map_err(get_git_hub_access_token::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_git_hub_access_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_git_hub_access_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GitHubAccessTokenResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_git_hub_access_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_git_hub_access_token::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_git_hub_access_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_artifacts_2020_12_01/mod.rs b/services/svc/synapse/src/package_artifacts_2020_12_01/mod.rs
new file mode 100644
index 0000000000..295814b1a2
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2020_12_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-12-01";
diff --git a/services/svc/synapse/src/package_artifacts_2020_12_01/models.rs b/services/svc/synapse/src/package_artifacts_2020_12_01/models.rs
new file mode 100644
index 0000000000..fda3d4a6b7
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2020_12_01/models.rs
@@ -0,0 +1,9451 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubResource {
+    #[serde(flatten)]
+    pub azure_entity_resource: AzureEntityResource,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubResourceDebugResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Expression {
+    #[serde(rename = "type")]
+    pub type_: expression::Type,
+    pub value: String,
+}
+pub mod expression {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Expression,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecureString {
+    #[serde(flatten)]
+    pub secret_base: SecretBase,
+    pub value: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultSecretReference {
+    #[serde(flatten)]
+    pub secret_base: SecretBase,
+    pub store: LinkedServiceReference,
+    #[serde(rename = "secretName")]
+    pub secret_name: serde_json::Value,
+    #[serde(rename = "secretVersion", default, skip_serializing_if = "Option::is_none")]
+    pub secret_version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecretBase {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeReference {
+    #[serde(rename = "type")]
+    pub type_: integration_runtime_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod integration_runtime_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        IntegrationRuntimeReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudError {
+    pub error: CloudErrorBody,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudErrorBody {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<CloudError>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerDependencyProvisioningStatus {
+    #[serde(rename = "triggerName")]
+    pub trigger_name: String,
+    #[serde(rename = "provisioningStatus")]
+    pub provisioning_status: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VariableDefinitionSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VariableSpecification {
+    #[serde(rename = "type")]
+    pub type_: variable_specification::Type,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+pub mod variable_specification {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        String,
+        Bool,
+        Boolean,
+        Array,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterDefinitionSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterSpecification {
+    #[serde(rename = "type")]
+    pub type_: parameter_specification::Type,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+pub mod parameter_specification {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Object,
+        String,
+        Int,
+        Float,
+        Bool,
+        Array,
+        SecureString,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterValueSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineReference {
+    #[serde(rename = "type")]
+    pub type_: pipeline_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+pub mod pipeline_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        PipelineReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerPipelineReference {
+    #[serde(rename = "pipelineReference", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_reference: Option<PipelineReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceUpdateParameters {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<WorkspaceIdentity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceIdentity {
+    #[serde(rename = "type")]
+    pub type_: workspace_identity::Type,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
+pub mod workspace_identity {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SystemAssigned,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetReference {
+    #[serde(rename = "type")]
+    pub type_: dataset_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod dataset_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        DatasetReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceReference {
+    #[serde(rename = "type")]
+    pub type_: linked_service_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod linked_service_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        LinkedServiceReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowReference {
+    #[serde(rename = "type")]
+    pub type_: data_flow_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(rename = "datasetParameters", default, skip_serializing_if = "Option::is_none")]
+    pub dataset_parameters: Option<serde_json::Value>,
+}
+pub mod data_flow_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        DataFlowReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowStagingInfo {
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunFilterParameters {
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+    #[serde(rename = "lastUpdatedAfter")]
+    pub last_updated_after: String,
+    #[serde(rename = "lastUpdatedBefore")]
+    pub last_updated_before: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub filters: Vec<RunQueryFilter>,
+    #[serde(rename = "orderBy", default, skip_serializing_if = "Vec::is_empty")]
+    pub order_by: Vec<RunQueryOrderBy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunQueryFilter {
+    pub operand: run_query_filter::Operand,
+    pub operator: run_query_filter::Operator,
+    pub values: Vec<String>,
+}
+pub mod run_query_filter {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operand {
+        PipelineName,
+        Status,
+        RunStart,
+        RunEnd,
+        ActivityName,
+        ActivityRunStart,
+        ActivityRunEnd,
+        ActivityType,
+        TriggerName,
+        TriggerRunTimestamp,
+        RunGroupId,
+        LatestOnly,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operator {
+        Equals,
+        NotEquals,
+        In,
+        NotIn,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunQueryOrderBy {
+    #[serde(rename = "orderBy")]
+    pub order_by: run_query_order_by::OrderBy,
+    pub order: run_query_order_by::Order,
+}
+pub mod run_query_order_by {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OrderBy {
+        RunStart,
+        RunEnd,
+        PipelineName,
+        Status,
+        ActivityName,
+        ActivityRunStart,
+        ActivityRunEnd,
+        TriggerName,
+        TriggerRunTimestamp,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Order {
+        #[serde(rename = "ASC")]
+        Asc,
+        #[serde(rename = "DESC")]
+        Desc,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTumblingWindowTriggerActionParameters {
+    #[serde(rename = "startTime")]
+    pub start_time: String,
+    #[serde(rename = "endTime")]
+    pub end_time: String,
+    #[serde(rename = "maxConcurrency")]
+    pub max_concurrency: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTriggerListResponse {
+    pub value: Vec<RerunTriggerResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTriggerResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: RerunTumblingWindowTrigger,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetSsisObjectMetadataRequest {
+    #[serde(rename = "metadataPath", default, skip_serializing_if = "Option::is_none")]
+    pub metadata_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisObjectMetadataStatusResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExposureControlRequest {
+    #[serde(rename = "featureName", default, skip_serializing_if = "Option::is_none")]
+    pub feature_name: Option<String>,
+    #[serde(rename = "featureType", default, skip_serializing_if = "Option::is_none")]
+    pub feature_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExposureControlResponse {
+    #[serde(rename = "featureName", default, skip_serializing_if = "Option::is_none")]
+    pub feature_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookReference {
+    #[serde(rename = "type")]
+    pub type_: synapse_notebook_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod synapse_notebook_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        NotebookReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobReference {
+    #[serde(rename = "type")]
+    pub type_: synapse_spark_job_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod synapse_spark_job_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SparkJobDefinitionReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolReference {
+    #[serde(rename = "type")]
+    pub type_: sql_pool_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod sql_pool_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlPoolReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ArtifactRenameRequest {
+    #[serde(rename = "newName", default, skip_serializing_if = "Option::is_none")]
+    pub new_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Trigger {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "runtimeState", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_state: Option<TriggerRuntimeState>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TriggerRuntimeState {
+    Started,
+    Stopped,
+    Disabled,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MultiplePipelineTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub pipelines: Vec<TriggerPipelineReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScheduleTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: schedule_trigger::TypeProperties,
+}
+pub mod schedule_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        pub recurrence: ScheduleTriggerRecurrence,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScheduleTriggerRecurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub frequency: Option<RecurrenceFrequency>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub interval: Option<i32>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(rename = "timeZone", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule: Option<RecurrenceSchedule>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum RecurrenceFrequency {
+    NotSpecified,
+    Minute,
+    Hour,
+    Day,
+    Week,
+    Month,
+    Year,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceSchedule {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub minutes: Vec<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub hours: Vec<i32>,
+    #[serde(rename = "weekDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub week_days: Vec<String>,
+    #[serde(rename = "monthDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub month_days: Vec<i32>,
+    #[serde(rename = "monthlyOccurrences", default, skip_serializing_if = "Vec::is_empty")]
+    pub monthly_occurrences: Vec<RecurrenceScheduleOccurrence>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceScheduleOccurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub day: Option<DayOfWeek>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub occurrence: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DayOfWeek {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: blob_trigger::TypeProperties,
+}
+pub mod blob_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "folderPath")]
+        pub folder_path: String,
+        #[serde(rename = "maxConcurrency")]
+        pub max_concurrency: i64,
+        #[serde(rename = "linkedService")]
+        pub linked_service: LinkedServiceReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobEventsTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: blob_events_trigger::TypeProperties,
+}
+pub mod blob_events_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "blobPathBeginsWith", default, skip_serializing_if = "Option::is_none")]
+        pub blob_path_begins_with: Option<String>,
+        #[serde(rename = "blobPathEndsWith", default, skip_serializing_if = "Option::is_none")]
+        pub blob_path_ends_with: Option<String>,
+        #[serde(rename = "ignoreEmptyBlobs", default, skip_serializing_if = "Option::is_none")]
+        pub ignore_empty_blobs: Option<bool>,
+        pub events: BlobEventTypes,
+        pub scope: String,
+    }
+}
+pub type BlobEventTypes = Vec<String>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomEventsTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: custom_events_trigger::TypeProperties,
+}
+pub mod custom_events_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "subjectBeginsWith", default, skip_serializing_if = "Option::is_none")]
+        pub subject_begins_with: Option<String>,
+        #[serde(rename = "subjectEndsWith", default, skip_serializing_if = "Option::is_none")]
+        pub subject_ends_with: Option<String>,
+        pub events: Vec<serde_json::Value>,
+        pub scope: String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TumblingWindowTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    pub pipeline: TriggerPipelineReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: tumbling_window_trigger::TypeProperties,
+}
+pub mod tumbling_window_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        pub frequency: TumblingWindowFrequency,
+        pub interval: i32,
+        #[serde(rename = "startTime")]
+        pub start_time: String,
+        #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+        pub end_time: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub delay: Option<serde_json::Value>,
+        #[serde(rename = "maxConcurrency")]
+        pub max_concurrency: i64,
+        #[serde(rename = "retryPolicy", default, skip_serializing_if = "Option::is_none")]
+        pub retry_policy: Option<RetryPolicy>,
+        #[serde(rename = "dependsOn", default, skip_serializing_if = "Vec::is_empty")]
+        pub depends_on: Vec<DependencyReference>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TumblingWindowFrequency {
+    Minute,
+    Hour,
+    Month,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RetryPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<serde_json::Value>,
+    #[serde(rename = "intervalInSeconds", default, skip_serializing_if = "Option::is_none")]
+    pub interval_in_seconds: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerReference {
+    #[serde(rename = "type")]
+    pub type_: trigger_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod trigger_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        TriggerReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DependencyReference {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerDependencyReference {
+    #[serde(flatten)]
+    pub dependency_reference: DependencyReference,
+    #[serde(rename = "referenceTrigger")]
+    pub reference_trigger: TriggerReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TumblingWindowTriggerDependencyReference {
+    #[serde(flatten)]
+    pub trigger_dependency_reference: TriggerDependencyReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offset: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SelfDependencyTumblingWindowTriggerReference {
+    #[serde(flatten)]
+    pub dependency_reference: DependencyReference,
+    pub offset: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTumblingWindowTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: rerun_tumbling_window_trigger::TypeProperties,
+}
+pub mod rerun_tumbling_window_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "parentTrigger")]
+        pub parent_trigger: serde_json::Value,
+        #[serde(rename = "requestedStartTime")]
+        pub requested_start_time: String,
+        #[serde(rename = "requestedEndTime")]
+        pub requested_end_time: String,
+        #[serde(rename = "rerunConcurrency")]
+        pub rerun_concurrency: i64,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ChainingTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    pub pipeline: TriggerPipelineReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: chaining_trigger::TypeProperties,
+}
+pub mod chaining_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "dependsOn")]
+        pub depends_on: Vec<PipelineReference>,
+        #[serde(rename = "runDimension")]
+        pub run_dimension: String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowListResponse {
+    pub value: Vec<DataFlowResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: DataFlow,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateDataFlowDebugSessionRequest {
+    #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+    pub compute_type: Option<String>,
+    #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+    pub core_count: Option<i64>,
+    #[serde(rename = "timeToLive", default, skip_serializing_if = "Option::is_none")]
+    pub time_to_live: Option<i64>,
+    #[serde(rename = "integrationRuntime", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime: Option<IntegrationRuntimeDebugResource>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: IntegrationRuntime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateDataFlowDebugSessionResponse {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryDataFlowDebugSessionsResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<DataFlowDebugSessionInfo>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugSessionInfo {
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+    pub compute_type: Option<String>,
+    #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+    pub core_count: Option<i64>,
+    #[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub node_count: Option<i64>,
+    #[serde(rename = "integrationRuntimeName", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime_name: Option<String>,
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "timeToLiveInMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub time_to_live_in_minutes: Option<i64>,
+    #[serde(rename = "lastActivityTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_activity_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugPackage {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlow", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow: Option<DataFlowDebugResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetDebugResource>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceDebugResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<DataFlowStagingInfo>,
+    #[serde(rename = "debugSettings", default, skip_serializing_if = "Option::is_none")]
+    pub debug_settings: Option<data_flow_debug_package::DebugSettings>,
+}
+pub mod data_flow_debug_package {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct DebugSettings {
+        #[serde(rename = "sourceSettings", default, skip_serializing_if = "Vec::is_empty")]
+        pub source_settings: Vec<DataFlowSourceSetting>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub parameters: Option<ParameterValueSpecification>,
+        #[serde(rename = "datasetParameters", default, skip_serializing_if = "Option::is_none")]
+        pub dataset_parameters: Option<serde_json::Value>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSourceSetting {
+    #[serde(rename = "sourceName", default, skip_serializing_if = "Option::is_none")]
+    pub source_name: Option<String>,
+    #[serde(rename = "rowLimit", default, skip_serializing_if = "Option::is_none")]
+    pub row_limit: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: DataFlow,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AddDataFlowToDebugSessionResponse {
+    #[serde(rename = "jobVersion", default, skip_serializing_if = "Option::is_none")]
+    pub job_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StartDataFlowDebugSessionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlow", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow: Option<DataFlowResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetResource>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<serde_json::Value>,
+    #[serde(rename = "debugSettings", default, skip_serializing_if = "Option::is_none")]
+    pub debug_settings: Option<serde_json::Value>,
+    #[serde(rename = "incrementalDebug", default, skip_serializing_if = "Option::is_none")]
+    pub incremental_debug: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StartDataFlowDebugSessionResponse {
+    #[serde(rename = "jobVersion", default, skip_serializing_if = "Option::is_none")]
+    pub job_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteDataFlowDebugSessionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugPreviewDataRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugStatisticsRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EvaluateDataFlowExpressionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expression: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub command: Option<data_flow_debug_command_request::Command>,
+    #[serde(rename = "commandPayload", default, skip_serializing_if = "Option::is_none")]
+    pub command_payload: Option<DataFlowDebugCommandPayload>,
+}
+pub mod data_flow_debug_command_request {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Command {
+        #[serde(rename = "executePreviewQuery")]
+        ExecutePreviewQuery,
+        #[serde(rename = "executeStatisticsQuery")]
+        ExecuteStatisticsQuery,
+        #[serde(rename = "executeExpressionQuery")]
+        ExecuteExpressionQuery,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandPayload {
+    #[serde(rename = "streamName")]
+    pub stream_name: String,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expression: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugQueryResponse {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugResultResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: LinkedService,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlow {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<data_flow::Folder>,
+}
+pub mod data_flow {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MappingDataFlow {
+    #[serde(flatten)]
+    pub data_flow: DataFlow,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MappingDataFlowTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MappingDataFlowTypeProperties {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sources: Vec<DataFlowSource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sinks: Vec<DataFlowSink>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub transformations: Vec<Transformation>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub script: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Transformation {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSource {
+    #[serde(flatten)]
+    pub transformation: Transformation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<DatasetReference>,
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "schemaLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub schema_linked_service: Option<LinkedServiceReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSink {
+    #[serde(flatten)]
+    pub transformation: Transformation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<DatasetReference>,
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "schemaLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub schema_linked_service: Option<LinkedServiceReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetListResponse {
+    pub value: Vec<DatasetResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Dataset {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub structure: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<dataset::Folder>,
+}
+pub mod dataset {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetLocation {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub container: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "fileSystem", default, skip_serializing_if = "Option::is_none")]
+    pub file_system: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Location {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "bucketName", default, skip_serializing_if = "Option::is_none")]
+    pub bucket_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "bucketName", default, skip_serializing_if = "Option::is_none")]
+    pub bucket_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDataElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetSchemaDataElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetStorageFormat {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub serializer: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub deserializer: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TextFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+    #[serde(rename = "columnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "rowDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub row_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "escapeChar", default, skip_serializing_if = "Option::is_none")]
+    pub escape_char: Option<serde_json::Value>,
+    #[serde(rename = "quoteChar", default, skip_serializing_if = "Option::is_none")]
+    pub quote_char: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_line_count: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+    #[serde(rename = "filePattern", default, skip_serializing_if = "Option::is_none")]
+    pub file_pattern: Option<serde_json::Value>,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "jsonNodeReference", default, skip_serializing_if = "Option::is_none")]
+    pub json_node_reference: Option<serde_json::Value>,
+    #[serde(rename = "jsonPathDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub json_path_definition: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JsonFormatFilePattern {
+    #[serde(rename = "setOfObjects")]
+    SetOfObjects,
+    #[serde(rename = "arrayOfObjects")]
+    ArrayOfObjects,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetCompression {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetBZip2Compression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetGZipCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDeflateCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetZipDeflateCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetTarCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetTarGZipCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompressionLevel {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DatasetCompressionLevelEnum {
+    Optimal,
+    Fastest,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Dataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonS3DatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3DatasetTypeProperties {
+    #[serde(rename = "bucketName")]
+    pub bucket_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AvroDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "avroCompressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub avro_compression_codec: Option<serde_json::Value>,
+    #[serde(rename = "avroCompressionLevel", default, skip_serializing_if = "Option::is_none")]
+    pub avro_compression_level: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AvroCompressionCodecEnum {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "deflate")]
+    Deflate,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "xz")]
+    Xz,
+    #[serde(rename = "bzip2")]
+    Bzip2,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ExcelDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "sheetName")]
+    pub sheet_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub range: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ParquetDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "compressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub compression_codec: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ParquetCompressionCodecEnum {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "gzip")]
+    Gzip,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lzo")]
+    Lzo,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DelimitedTextDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "columnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "rowDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub row_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "compressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub compression_codec: Option<serde_json::Value>,
+    #[serde(rename = "compressionLevel", default, skip_serializing_if = "Option::is_none")]
+    pub compression_level: Option<serde_json::Value>,
+    #[serde(rename = "quoteChar", default, skip_serializing_if = "Option::is_none")]
+    pub quote_char: Option<serde_json::Value>,
+    #[serde(rename = "escapeChar", default, skip_serializing_if = "Option::is_none")]
+    pub escape_char: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum CompressionCodec {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "lzo")]
+    Lzo,
+    #[serde(rename = "bzip2")]
+    Bzip2,
+    #[serde(rename = "gzip")]
+    Gzip,
+    #[serde(rename = "deflate")]
+    Deflate,
+    #[serde(rename = "zipDeflate")]
+    ZipDeflate,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lz4")]
+    Lz4,
+    #[serde(rename = "tar")]
+    Tar,
+    #[serde(rename = "tarGZip")]
+    TarGZip,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<JsonDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<XmlDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OrcDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "orcCompressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub orc_compression_codec: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum OrcCompressionCodec {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "zlib")]
+    Zlib,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lzo")]
+    Lzo,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<BinaryDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureBlobDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "tableRootLocation", default, skip_serializing_if = "Option::is_none")]
+    pub table_root_location: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableDatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlMiTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlDwTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<CassandraTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub keyspace: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbSqlApiCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DocumentDbCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DynamicsEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DynamicsCrmEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<CommonDataServiceForAppsEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureDataLakeStoreDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureBlobFsDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365Dataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Office365DatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365DatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub predicate: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileShareDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<FileShareDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileShareDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(rename = "fileFilter", default, skip_serializing_if = "Option::is_none")]
+    pub file_filter: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbAtlasCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasCollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2CollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbV2CollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2CollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbMongoDbApiCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiCollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ODataResourceDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataResourceDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OracleTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRdsForOracleTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<TeradataTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMySqlTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRedshiftTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2TableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<Db2TableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2TableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<RelationalTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<InformixTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OdbcTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MySqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PostgreSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MicrosoftAccessTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SalesforceObjectDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceObjectDatasetTypeProperties {
+    #[serde(rename = "objectApiName", default, skip_serializing_if = "Option::is_none")]
+    pub object_api_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SalesforceServiceCloudObjectDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudObjectDatasetTypeProperties {
+    #[serde(rename = "objectApiName", default, skip_serializing_if = "Option::is_none")]
+    pub object_api_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SybaseTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwCubeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapCloudForCustomerResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapEccResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SapHanaTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapOpenHubTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubTableDatasetTypeProperties {
+    #[serde(rename = "openHubDestinationName")]
+    pub open_hub_destination_name: serde_json::Value,
+    #[serde(rename = "excludeLastRequest", default, skip_serializing_if = "Option::is_none")]
+    pub exclude_last_request: Option<serde_json::Value>,
+    #[serde(rename = "baseRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub base_request_id: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SqlServerTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRdsForSqlServerTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<RestResourceDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestResourceDatasetTypeProperties {
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "paginationRules", default, skip_serializing_if = "Option::is_none")]
+    pub pagination_rules: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapTableResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableResourceDatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebTableDatasetTypeProperties {
+    pub index: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSearchIndexDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexDatasetTypeProperties {
+    #[serde(rename = "indexName")]
+    pub index_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<HttpDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpDatasetTypeProperties {
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzurePostgreSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DrillDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GoogleBigQueryDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GreenplumDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<HiveDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ImpalaDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PhoenixDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PrestoDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SparkDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<NetezzaTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<VerticaDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsAxResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SnowflakeDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SharePointOnlineListDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListDatasetTypeProperties {
+    #[serde(rename = "listName", default, skip_serializing_if = "Option::is_none")]
+    pub list_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureDatabricksDeltaLakeDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceListResponse {
+    pub value: Vec<LinkedServiceResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: LinkedService,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedService {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "connectVia", default, skip_serializing_if = "Option::is_none")]
+    pub connect_via: Option<IntegrationRuntimeReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBlobStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "serviceEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub service_endpoint: Option<String>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "accountKind", default, skip_serializing_if = "Option::is_none")]
+    pub account_kind: Option<String>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlDwLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRdsForSqlServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlDatabaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlMiLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBatchLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBatchLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBatchLinkedServiceTypeProperties {
+    #[serde(rename = "accountName")]
+    pub account_name: serde_json::Value,
+    #[serde(rename = "accessKey", default, skip_serializing_if = "Option::is_none")]
+    pub access_key: Option<SecretBase>,
+    #[serde(rename = "batchUri")]
+    pub batch_uri: serde_json::Value,
+    #[serde(rename = "poolName")]
+    pub pool_name: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureKeyVaultLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultLinkedServiceTypeProperties {
+    #[serde(rename = "baseUrl")]
+    pub base_url: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub account_endpoint: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsDeploymentType {
+    Online,
+    OnPremisesWithIfd,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsAuthenticationType {
+    Office365,
+    Ifd,
+    #[serde(rename = "AADServicePrincipal")]
+    AadServicePrincipal,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsCrmLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ServicePrincipalCredentialEnum {
+    ServicePrincipalKey,
+    ServicePrincipalCert,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CommonDataServiceForAppsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightLinkedServiceTypeProperties {
+    #[serde(rename = "clusterUri")]
+    pub cluster_uri: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "hcatalogLinkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub hcatalog_linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "isEspEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_esp_enabled: Option<serde_json::Value>,
+    #[serde(rename = "fileSystem", default, skip_serializing_if = "Option::is_none")]
+    pub file_system: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FileServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFileStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "fileShare", default, skip_serializing_if = "Option::is_none")]
+    pub file_share: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub snapshot: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleCloudStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLinkedServiceTypeProperties {
+    #[serde(rename = "accessKeyId", default, skip_serializing_if = "Option::is_none")]
+    pub access_key_id: Option<serde_json::Value>,
+    #[serde(rename = "secretAccessKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_access_key: Option<SecretBase>,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OracleLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRdsForLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMySqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MySqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PostgreSqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SybaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sybase_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod sybase_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Db2LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2LinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    pub server: serde_json::Value,
+    pub database: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<db2_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "packageCollection", default, skip_serializing_if = "Option::is_none")]
+    pub package_collection: Option<serde_json::Value>,
+    #[serde(rename = "certificateCommonName", default, skip_serializing_if = "Option::is_none")]
+    pub certificate_common_name: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod db2_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: TeradataLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<teradata_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod teradata_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlLinkedServiceTypeProperties {
+    #[serde(rename = "mlEndpoint")]
+    pub ml_endpoint: serde_json::Value,
+    #[serde(rename = "apiKey")]
+    pub api_key: SecretBase,
+    #[serde(rename = "updateResourceEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub update_resource_endpoint: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlServiceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlServiceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlServiceLinkedServiceTypeProperties {
+    #[serde(rename = "subscriptionId")]
+    pub subscription_id: serde_json::Value,
+    #[serde(rename = "resourceGroupName")]
+    pub resource_group_name: serde_json::Value,
+    #[serde(rename = "mlWorkspaceName")]
+    pub ml_workspace_name: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OdbcLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: InformixLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MicrosoftAccessLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdfsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ODataLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<o_data_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "aadResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub aad_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "aadServicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub aad_service_principal_credential_type: Option<o_data_linked_service_type_properties::AadServicePrincipalCredentialType>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalEmbeddedCert", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_embedded_cert: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalEmbeddedCertPassword", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_embedded_cert_password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod o_data_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        Windows,
+        AadServicePrincipal,
+        ManagedServiceIdentity,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AadServicePrincipalCredentialType {
+        ServicePrincipalKey,
+        ServicePrincipalCert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: web_linked_service_type_properties::AuthenticationType,
+}
+pub mod web_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        ClientCertificate,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebAnonymousAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebBasicAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+    pub username: serde_json::Value,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebClientCertificateAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+    pub pfx: SecretBase,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CassandraLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<mongo_db_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "databaseName")]
+    pub database_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "authSource", default, skip_serializing_if = "Option::is_none")]
+    pub auth_source: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod mongo_db_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbAtlasLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbV2LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2LinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbMongoDbApiLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataLakeStoreLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLinkedServiceTypeProperties {
+    #[serde(rename = "dataLakeStoreUri")]
+    pub data_lake_store_uri: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<serde_json::Value>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<serde_json::Value>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBlobFsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Office365LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365LinkedServiceTypeProperties {
+    #[serde(rename = "office365TenantId")]
+    pub office365_tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalTenantId")]
+    pub service_principal_tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceLinkedServiceTypeProperties {
+    #[serde(rename = "environmentUrl", default, skip_serializing_if = "Option::is_none")]
+    pub environment_url: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "securityToken", default, skip_serializing_if = "Option::is_none")]
+    pub security_token: Option<SecretBase>,
+    #[serde(rename = "apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceServiceCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudLinkedServiceTypeProperties {
+    #[serde(rename = "environmentUrl", default, skip_serializing_if = "Option::is_none")]
+    pub environment_url: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "securityToken", default, skip_serializing_if = "Option::is_none")]
+    pub security_token: Option<SecretBase>,
+    #[serde(rename = "apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<serde_json::Value>,
+    #[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapCloudForCustomerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapEccLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccLinkedServiceTypeProperties {
+    pub url: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapOpenHubLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "systemNumber")]
+    pub system_number: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<serde_json::Value>,
+    #[serde(rename = "systemId", default, skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "messageServer", default, skip_serializing_if = "Option::is_none")]
+    pub message_server: Option<serde_json::Value>,
+    #[serde(rename = "messageServerService", default, skip_serializing_if = "Option::is_none")]
+    pub message_server_service: Option<serde_json::Value>,
+    #[serde(rename = "logonGroup", default, skip_serializing_if = "Option::is_none")]
+    pub logon_group: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestServiceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: RestServiceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestServiceLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: rest_service_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "aadResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub aad_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod rest_service_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Basic,
+        AadServicePrincipal,
+        ManagedServiceIdentity,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonS3LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3LinkedServiceTypeProperties {
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(rename = "accessKeyId", default, skip_serializing_if = "Option::is_none")]
+    pub access_key_id: Option<serde_json::Value>,
+    #[serde(rename = "secretAccessKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_access_key: Option<SecretBase>,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<serde_json::Value>,
+    #[serde(rename = "sessionToken", default, skip_serializing_if = "Option::is_none")]
+    pub session_token: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRedshiftLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomDataSourceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSearchLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HttpLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<http_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "embeddedCertData", default, skip_serializing_if = "Option::is_none")]
+    pub embedded_cert_data: Option<serde_json::Value>,
+    #[serde(rename = "certThumbprint", default, skip_serializing_if = "Option::is_none")]
+    pub cert_thumbprint: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+}
+pub mod http_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        Digest,
+        Windows,
+        ClientCertificate,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FtpServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<ftp_server_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+}
+pub mod ftp_server_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SftpServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sftp_server_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "privateKeyPath", default, skip_serializing_if = "Option::is_none")]
+    pub private_key_path: Option<serde_json::Value>,
+    #[serde(rename = "privateKeyContent", default, skip_serializing_if = "Option::is_none")]
+    pub private_key_content: Option<SecretBase>,
+    #[serde(rename = "passPhrase", default, skip_serializing_if = "Option::is_none")]
+    pub pass_phrase: Option<SecretBase>,
+    #[serde(rename = "skipHostKeyValidation", default, skip_serializing_if = "Option::is_none")]
+    pub skip_host_key_validation: Option<serde_json::Value>,
+    #[serde(rename = "hostKeyFingerprint", default, skip_serializing_if = "Option::is_none")]
+    pub host_key_fingerprint: Option<serde_json::Value>,
+}
+pub mod sftp_server_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        SshPublicKey,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapBwLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "systemNumber")]
+    pub system_number: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapHanaLinkedServiceProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaLinkedServiceProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    pub server: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sap_hana_linked_service_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod sap_hana_linked_service_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonMwsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "marketplaceID")]
+    pub marketplace_id: serde_json::Value,
+    #[serde(rename = "sellerID")]
+    pub seller_id: serde_json::Value,
+    #[serde(rename = "mwsAuthToken", default, skip_serializing_if = "Option::is_none")]
+    pub mws_auth_token: Option<SecretBase>,
+    #[serde(rename = "accessKeyId")]
+    pub access_key_id: serde_json::Value,
+    #[serde(rename = "secretKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_key: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzurePostgreSqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ConcurLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CouchbaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "credString", default, skip_serializing_if = "Option::is_none")]
+    pub cred_string: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DrillLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: EloquaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleBigQueryLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryLinkedServiceTypeProperties {
+    pub project: serde_json::Value,
+    #[serde(rename = "additionalProjects", default, skip_serializing_if = "Option::is_none")]
+    pub additional_projects: Option<serde_json::Value>,
+    #[serde(rename = "requestGoogleDriveScope", default, skip_serializing_if = "Option::is_none")]
+    pub request_google_drive_scope: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: google_big_query_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub email: Option<serde_json::Value>,
+    #[serde(rename = "keyFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub key_file_path: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod google_big_query_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        ServiceAuthentication,
+        UserAuthentication,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GreenplumLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HBaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: h_base_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod h_base_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Basic,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HiveLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serverType", default, skip_serializing_if = "Option::is_none")]
+    pub server_type: Option<hive_linked_service_type_properties::ServerType>,
+    #[serde(rename = "thriftTransportProtocol", default, skip_serializing_if = "Option::is_none")]
+    pub thrift_transport_protocol: Option<hive_linked_service_type_properties::ThriftTransportProtocol>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: hive_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "serviceDiscoveryMode", default, skip_serializing_if = "Option::is_none")]
+    pub service_discovery_mode: Option<serde_json::Value>,
+    #[serde(rename = "zooKeeperNameSpace", default, skip_serializing_if = "Option::is_none")]
+    pub zoo_keeper_name_space: Option<serde_json::Value>,
+    #[serde(rename = "useNativeQuery", default, skip_serializing_if = "Option::is_none")]
+    pub use_native_query: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod hive_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServerType {
+        HiveServer1,
+        HiveServer2,
+        HiveThriftServer,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ThriftTransportProtocol {
+        Binary,
+        #[serde(rename = "SASL")]
+        Sasl,
+        #[serde(rename = "HTTP ")]
+        Http,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Username,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HubspotLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotLinkedServiceTypeProperties {
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ImpalaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: impala_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod impala_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        #[serde(rename = "SASLUsername")]
+        SaslUsername,
+        UsernameAndPassword,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: JiraLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MagentoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MariaDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMariaDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MarketoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PaypalLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PhoenixLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: phoenix_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod phoenix_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PrestoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "serverVersion")]
+    pub server_version: serde_json::Value,
+    pub catalog: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: presto_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "timeZoneID", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod presto_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        #[serde(rename = "LDAP")]
+        Ldap,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: QuickBooksLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "companyId")]
+    pub company_id: serde_json::Value,
+    #[serde(rename = "consumerKey")]
+    pub consumer_key: serde_json::Value,
+    #[serde(rename = "consumerSecret")]
+    pub consumer_secret: SecretBase,
+    #[serde(rename = "accessToken")]
+    pub access_token: SecretBase,
+    #[serde(rename = "accessTokenSecret")]
+    pub access_token_secret: SecretBase,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ServiceNowLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: service_now_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod service_now_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        OAuth2,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ShopifyLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SparkLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    pub port: serde_json::Value,
+    #[serde(rename = "serverType", default, skip_serializing_if = "Option::is_none")]
+    pub server_type: Option<spark_linked_service_type_properties::ServerType>,
+    #[serde(rename = "thriftTransportProtocol", default, skip_serializing_if = "Option::is_none")]
+    pub thrift_transport_protocol: Option<spark_linked_service_type_properties::ThriftTransportProtocol>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: spark_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod spark_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServerType {
+        SharkServer,
+        SharkServer2,
+        SparkThriftServer,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ThriftTransportProtocol {
+        Binary,
+        #[serde(rename = "SASL")]
+        Sasl,
+        #[serde(rename = "HTTP ")]
+        Http,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Username,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SquareLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub host: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "redirectUri")]
+    pub redirect_uri: serde_json::Value,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: XeroLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub host: serde_json::Value,
+    #[serde(rename = "consumerKey", default, skip_serializing_if = "Option::is_none")]
+    pub consumer_key: Option<SecretBase>,
+    #[serde(rename = "privateKey", default, skip_serializing_if = "Option::is_none")]
+    pub private_key: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ZohoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: VerticaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: NetezzaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceMarketingCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightOnDemandLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightOnDemandLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightOnDemandLinkedServiceTypeProperties {
+    #[serde(rename = "clusterSize")]
+    pub cluster_size: serde_json::Value,
+    #[serde(rename = "timeToLive")]
+    pub time_to_live: serde_json::Value,
+    pub version: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(rename = "hostSubscriptionId")]
+    pub host_subscription_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "clusterResourceGroup")]
+    pub cluster_resource_group: serde_json::Value,
+    #[serde(rename = "clusterNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_name_prefix: Option<serde_json::Value>,
+    #[serde(rename = "clusterUserName", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_user_name: Option<serde_json::Value>,
+    #[serde(rename = "clusterPassword", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_password: Option<SecretBase>,
+    #[serde(rename = "clusterSshUserName", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_ssh_user_name: Option<serde_json::Value>,
+    #[serde(rename = "clusterSshPassword", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_ssh_password: Option<SecretBase>,
+    #[serde(rename = "additionalLinkedServiceNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_linked_service_names: Vec<LinkedServiceReference>,
+    #[serde(rename = "hcatalogLinkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub hcatalog_linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "clusterType", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_type: Option<serde_json::Value>,
+    #[serde(rename = "sparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub spark_version: Option<serde_json::Value>,
+    #[serde(rename = "coreConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub core_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hBaseConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub h_base_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hdfsConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub hdfs_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hiveConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub hive_configuration: Option<serde_json::Value>,
+    #[serde(rename = "mapReduceConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub map_reduce_configuration: Option<serde_json::Value>,
+    #[serde(rename = "oozieConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub oozie_configuration: Option<serde_json::Value>,
+    #[serde(rename = "stormConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub storm_configuration: Option<serde_json::Value>,
+    #[serde(rename = "yarnConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_configuration: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "headNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub head_node_size: Option<serde_json::Value>,
+    #[serde(rename = "dataNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub data_node_size: Option<serde_json::Value>,
+    #[serde(rename = "zookeeperNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub zookeeper_node_size: Option<serde_json::Value>,
+    #[serde(rename = "scriptActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub script_actions: Vec<ScriptAction>,
+    #[serde(rename = "virtualNetworkId", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_network_id: Option<serde_json::Value>,
+    #[serde(rename = "subnetName", default, skip_serializing_if = "Option::is_none")]
+    pub subnet_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScriptAction {
+    pub name: String,
+    pub uri: String,
+    pub roles: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum HdiNodeTypes {
+    Headnode,
+    Workernode,
+    Zookeeper,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeAnalyticsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataLakeAnalyticsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeAnalyticsLinkedServiceTypeProperties {
+    #[serde(rename = "accountName")]
+    pub account_name: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<serde_json::Value>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<serde_json::Value>,
+    #[serde(rename = "dataLakeAnalyticsUri", default, skip_serializing_if = "Option::is_none")]
+    pub data_lake_analytics_uri: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDatabricksLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksLinkedServiceTypeProperties {
+    pub domain: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<serde_json::Value>,
+    #[serde(rename = "workspaceResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "existingClusterId", default, skip_serializing_if = "Option::is_none")]
+    pub existing_cluster_id: Option<serde_json::Value>,
+    #[serde(rename = "instancePoolId", default, skip_serializing_if = "Option::is_none")]
+    pub instance_pool_id: Option<serde_json::Value>,
+    #[serde(rename = "newClusterVersion", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_version: Option<serde_json::Value>,
+    #[serde(rename = "newClusterNumOfWorker", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_num_of_worker: Option<serde_json::Value>,
+    #[serde(rename = "newClusterNodeType", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_node_type: Option<serde_json::Value>,
+    #[serde(rename = "newClusterSparkConf", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_spark_conf: Option<serde_json::Value>,
+    #[serde(rename = "newClusterSparkEnvVars", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_spark_env_vars: Option<serde_json::Value>,
+    #[serde(rename = "newClusterCustomTags", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_custom_tags: Option<serde_json::Value>,
+    #[serde(rename = "newClusterLogDestination", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_log_destination: Option<serde_json::Value>,
+    #[serde(rename = "newClusterDriverNodeType", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_driver_node_type: Option<serde_json::Value>,
+    #[serde(rename = "newClusterInitScripts", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_init_scripts: Option<serde_json::Value>,
+    #[serde(rename = "newClusterEnableElasticDisk", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_enable_elastic_disk: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "policyId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_id: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDatabricksDetltaLakeLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDetltaLakeLinkedServiceTypeProperties {
+    pub domain: serde_json::Value,
+    #[serde(rename = "accessToken")]
+    pub access_token: SecretBase,
+    #[serde(rename = "clusterId", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ResponsysLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsAxLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "aadResourceId")]
+    pub aad_resource_id: serde_json::Value,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OracleServiceCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    pub username: serde_json::Value,
+    pub password: SecretBase,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleAdWordsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsLinkedServiceTypeProperties {
+    #[serde(rename = "clientCustomerID")]
+    pub client_customer_id: serde_json::Value,
+    #[serde(rename = "developerToken")]
+    pub developer_token: SecretBase,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: google_ad_words_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub email: Option<serde_json::Value>,
+    #[serde(rename = "keyFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub key_file_path: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod google_ad_words_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        ServiceAuthentication,
+        UserAuthentication,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapTableLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableLinkedServiceTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<serde_json::Value>,
+    #[serde(rename = "systemNumber", default, skip_serializing_if = "Option::is_none")]
+    pub system_number: Option<serde_json::Value>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<serde_json::Value>,
+    #[serde(rename = "systemId", default, skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "messageServer", default, skip_serializing_if = "Option::is_none")]
+    pub message_server: Option<serde_json::Value>,
+    #[serde(rename = "messageServerService", default, skip_serializing_if = "Option::is_none")]
+    pub message_server_service: Option<serde_json::Value>,
+    #[serde(rename = "sncMode", default, skip_serializing_if = "Option::is_none")]
+    pub snc_mode: Option<serde_json::Value>,
+    #[serde(rename = "sncMyName", default, skip_serializing_if = "Option::is_none")]
+    pub snc_my_name: Option<serde_json::Value>,
+    #[serde(rename = "sncPartnerName", default, skip_serializing_if = "Option::is_none")]
+    pub snc_partner_name: Option<serde_json::Value>,
+    #[serde(rename = "sncLibraryPath", default, skip_serializing_if = "Option::is_none")]
+    pub snc_library_path: Option<serde_json::Value>,
+    #[serde(rename = "sncQop", default, skip_serializing_if = "Option::is_none")]
+    pub snc_qop: Option<serde_json::Value>,
+    #[serde(rename = "logonGroup", default, skip_serializing_if = "Option::is_none")]
+    pub logon_group: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFunctionLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionLinkedServiceTypeProperties {
+    #[serde(rename = "functionAppUrl")]
+    pub function_app_url: serde_json::Value,
+    #[serde(rename = "functionKey", default, skip_serializing_if = "Option::is_none")]
+    pub function_key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SnowflakeLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SharePointOnlineListLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListLinkedServiceTypeProperties {
+    #[serde(rename = "siteUrl")]
+    pub site_url: serde_json::Value,
+    #[serde(rename = "tenantId")]
+    pub tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubAccessTokenRequest {
+    #[serde(rename = "gitHubClientId")]
+    pub git_hub_client_id: String,
+    #[serde(rename = "gitHubAccessCode")]
+    pub git_hub_access_code: String,
+    #[serde(rename = "gitHubAccessTokenBaseUrl")]
+    pub git_hub_access_token_base_url: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubAccessTokenResponse {
+    #[serde(rename = "gitHubAccessToken", default, skip_serializing_if = "Option::is_none")]
+    pub git_hub_access_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OperationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<CloudErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryListResponse {
+    pub value: Vec<LibraryResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResourceInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "recordId", default, skip_serializing_if = "Option::is_none")]
+    pub record_id: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub created: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub changed: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "operationId", default, skip_serializing_if = "Option::is_none")]
+    pub operation_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: LibraryResourceProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResourceProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "containerName", default, skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+    #[serde(rename = "uploadedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub uploaded_timestamp: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<String>,
+    #[serde(rename = "creatorId", default, skip_serializing_if = "Option::is_none")]
+    pub creator_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookListResponse {
+    pub value: Vec<NotebookResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    pub properties: Notebook,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Notebook {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "bigDataPool", default, skip_serializing_if = "Option::is_none")]
+    pub big_data_pool: Option<BigDataPoolReference>,
+    #[serde(rename = "sessionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub session_properties: Option<NotebookSessionProperties>,
+    pub metadata: NotebookMetadata,
+    pub nbformat: i64,
+    pub nbformat_minor: i64,
+    pub cells: Vec<NotebookCell>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<notebook::Folder>,
+}
+pub mod notebook {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolReference {
+    #[serde(rename = "type")]
+    pub type_: big_data_pool_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod big_data_pool_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        BigDataPoolReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookMetadata {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kernelspec: Option<NotebookKernelSpec>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language_info: Option<NotebookLanguageInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookKernelSpec {
+    pub name: String,
+    pub display_name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookLanguageInfo {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub codemirror_mode: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookCell {
+    pub cell_type: String,
+    pub metadata: serde_json::Value,
+    pub source: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub attachments: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<NotebookCellOutputItem>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookSessionProperties {
+    #[serde(rename = "driverMemory")]
+    pub driver_memory: String,
+    #[serde(rename = "driverCores")]
+    pub driver_cores: i64,
+    #[serde(rename = "executorMemory")]
+    pub executor_memory: String,
+    #[serde(rename = "executorCores")]
+    pub executor_cores: i64,
+    #[serde(rename = "numExecutors")]
+    pub num_executors: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookCellOutputItem {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub execution_count: Option<i64>,
+    pub output_type: notebook_cell_output_item::OutputType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub text: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+}
+pub mod notebook_cell_output_item {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OutputType {
+        #[serde(rename = "execute_result")]
+        ExecuteResult,
+        #[serde(rename = "display_data")]
+        DisplayData,
+        #[serde(rename = "stream")]
+        Stream,
+        #[serde(rename = "error")]
+        Error,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineListResponse {
+    pub value: Vec<PipelineResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Pipeline,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateRunResponse {
+    #[serde(rename = "runId")]
+    pub run_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRunsQueryResponse {
+    pub value: Vec<PipelineRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRun {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "runGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub run_group_id: Option<String>,
+    #[serde(rename = "isLatest", default, skip_serializing_if = "Option::is_none")]
+    pub is_latest: Option<bool>,
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<serde_json::Value>,
+    #[serde(rename = "invokedBy", default, skip_serializing_if = "Option::is_none")]
+    pub invoked_by: Option<PipelineRunInvokedBy>,
+    #[serde(rename = "lastUpdated", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated: Option<String>,
+    #[serde(rename = "runStart", default, skip_serializing_if = "Option::is_none")]
+    pub run_start: Option<String>,
+    #[serde(rename = "runEnd", default, skip_serializing_if = "Option::is_none")]
+    pub run_end: Option<String>,
+    #[serde(rename = "durationInMs", default, skip_serializing_if = "Option::is_none")]
+    pub duration_in_ms: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRunInvokedBy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "invokedByType", default, skip_serializing_if = "Option::is_none")]
+    pub invoked_by_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityRunsQueryResponse {
+    pub value: Vec<ActivityRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityRun {
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(rename = "pipelineRunId", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_run_id: Option<String>,
+    #[serde(rename = "activityName", default, skip_serializing_if = "Option::is_none")]
+    pub activity_name: Option<String>,
+    #[serde(rename = "activityType", default, skip_serializing_if = "Option::is_none")]
+    pub activity_type: Option<String>,
+    #[serde(rename = "activityRunId", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_id: Option<String>,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "activityRunStart", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_start: Option<String>,
+    #[serde(rename = "activityRunEnd", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_end: Option<String>,
+    #[serde(rename = "durationInMs", default, skip_serializing_if = "Option::is_none")]
+    pub duration_in_ms: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub input: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Pipeline {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub activities: Vec<Activity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub variables: Option<VariableDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub concurrency: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(rename = "runDimensions", default, skip_serializing_if = "Option::is_none")]
+    pub run_dimensions: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<pipeline::Folder>,
+}
+pub mod pipeline {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Activity {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "dependsOn", default, skip_serializing_if = "Vec::is_empty")]
+    pub depends_on: Vec<ActivityDependency>,
+    #[serde(rename = "userProperties", default, skip_serializing_if = "Vec::is_empty")]
+    pub user_properties: Vec<UserProperty>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserProperty {
+    pub name: String,
+    pub value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityDependency {
+    pub activity: String,
+    #[serde(rename = "dependencyConditions")]
+    pub dependency_conditions: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ControlActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutionActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub policy: Option<ActivityPolicy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub retry: Option<serde_json::Value>,
+    #[serde(rename = "retryIntervalInSeconds", default, skip_serializing_if = "Option::is_none")]
+    pub retry_interval_in_seconds: Option<i64>,
+    #[serde(rename = "secureInput", default, skip_serializing_if = "Option::is_none")]
+    pub secure_input: Option<bool>,
+    #[serde(rename = "secureOutput", default, skip_serializing_if = "Option::is_none")]
+    pub secure_output: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoreReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "listAfter", default, skip_serializing_if = "Option::is_none")]
+    pub list_after: Option<serde_json::Value>,
+    #[serde(rename = "listBefore", default, skip_serializing_if = "Option::is_none")]
+    pub list_before: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3ReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(rename = "fileFilter", default, skip_serializing_if = "Option::is_none")]
+    pub file_filter: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "operationTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub operation_timeout: Option<serde_json::Value>,
+    #[serde(rename = "useTempFileRename", default, skip_serializing_if = "Option::is_none")]
+    pub use_temp_file_rename: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "useBinaryTransfer", default, skip_serializing_if = "Option::is_none")]
+    pub use_binary_transfer: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "requestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(rename = "distcpSettings", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_settings: Option<DistcpSettings>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoreWriteSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "blockSizeInMB", default, skip_serializing_if = "Option::is_none")]
+    pub block_size_in_mb: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "blockSizeInMB", default, skip_serializing_if = "Option::is_none")]
+    pub block_size_in_mb: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "expiryDateTime", default, skip_serializing_if = "Option::is_none")]
+    pub expiry_date_time: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FormatReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompressionReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZipDeflateReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveZipFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_zip_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TarReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveCompressionFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_compression_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TarGZipReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveCompressionFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_compression_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "skipLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_line_count: Option<serde_json::Value>,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+    #[serde(rename = "validationMode", default, skip_serializing_if = "Option::is_none")]
+    pub validation_mode: Option<serde_json::Value>,
+    #[serde(rename = "detectDataType", default, skip_serializing_if = "Option::is_none")]
+    pub detect_data_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub namespaces: Option<serde_json::Value>,
+    #[serde(rename = "namespacePrefixes", default, skip_serializing_if = "Option::is_none")]
+    pub namespace_prefixes: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FormatWriteSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "recordName", default, skip_serializing_if = "Option::is_none")]
+    pub record_name: Option<String>,
+    #[serde(rename = "recordNamespace", default, skip_serializing_if = "Option::is_none")]
+    pub record_namespace: Option<String>,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "quoteAllText", default, skip_serializing_if = "Option::is_none")]
+    pub quote_all_text: Option<serde_json::Value>,
+    #[serde(rename = "fileExtension")]
+    pub file_extension: serde_json::Value,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "filePattern", default, skip_serializing_if = "Option::is_none")]
+    pub file_pattern: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JsonWriteFilePattern {
+    #[serde(rename = "setOfObjects")]
+    SetOfObjects,
+    #[serde(rename = "arrayOfObjects")]
+    ArrayOfObjects,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<DelimitedTextReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<JsonReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<XmlReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<DelimitedTextWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<JsonWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<OrcWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CopyActivityTypeProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub inputs: Vec<DatasetReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<DatasetReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivityTypeProperties {
+    pub source: CopySource,
+    pub sink: CopySink,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub translator: Option<serde_json::Value>,
+    #[serde(rename = "enableStaging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_staging: Option<serde_json::Value>,
+    #[serde(rename = "stagingSettings", default, skip_serializing_if = "Option::is_none")]
+    pub staging_settings: Option<StagingSettings>,
+    #[serde(rename = "parallelCopies", default, skip_serializing_if = "Option::is_none")]
+    pub parallel_copies: Option<serde_json::Value>,
+    #[serde(rename = "dataIntegrationUnits", default, skip_serializing_if = "Option::is_none")]
+    pub data_integration_units: Option<serde_json::Value>,
+    #[serde(rename = "enableSkipIncompatibleRow", default, skip_serializing_if = "Option::is_none")]
+    pub enable_skip_incompatible_row: Option<serde_json::Value>,
+    #[serde(rename = "redirectIncompatibleRowSettings", default, skip_serializing_if = "Option::is_none")]
+    pub redirect_incompatible_row_settings: Option<RedirectIncompatibleRowSettings>,
+    #[serde(rename = "logStorageSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_storage_settings: Option<LogStorageSettings>,
+    #[serde(rename = "logSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_settings: Option<LogSettings>,
+    #[serde(rename = "preserveRules", default, skip_serializing_if = "Vec::is_empty")]
+    pub preserve_rules: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub preserve: Vec<serde_json::Value>,
+    #[serde(rename = "validateDataConsistency", default, skip_serializing_if = "Option::is_none")]
+    pub validate_data_consistency: Option<serde_json::Value>,
+    #[serde(rename = "skipErrorFile", default, skip_serializing_if = "Option::is_none")]
+    pub skip_error_file: Option<SkipErrorFile>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopySource {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "sourceRetryCount", default, skip_serializing_if = "Option::is_none")]
+    pub source_retry_count: Option<serde_json::Value>,
+    #[serde(rename = "sourceRetryWait", default, skip_serializing_if = "Option::is_none")]
+    pub source_retry_wait: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinarySource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<BinaryReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TabularSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "azureTableSourceQuery", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_source_query: Option<serde_json::Value>,
+    #[serde(rename = "azureTableSourceIgnoreTableNotFound", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_source_ignore_table_not_found: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipHeaderLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_header_line_count: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "pageSize", default, skip_serializing_if = "Option::is_none")]
+    pub page_size: Option<serde_json::Value>,
+    #[serde(rename = "preferredRegions", default, skip_serializing_if = "Option::is_none")]
+    pub preferred_regions: Option<serde_json::Value>,
+    #[serde(rename = "detectDatetime", default, skip_serializing_if = "Option::is_none")]
+    pub detect_datetime: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2Source {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "readBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub read_behavior: Option<salesforce_source::ReadBehavior>,
+}
+pub mod salesforce_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ReadBehavior {
+        Query,
+        QueryAll,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "readBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub read_behavior: Option<salesforce_service_cloud_source::ReadBehavior>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+pub mod salesforce_service_cloud_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ReadBehavior {
+        Query,
+        QueryAll,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "packetSize", default, skip_serializing_if = "Option::is_none")]
+    pub packet_size: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<sap_hana_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SapHanaPartitionSettings>,
+}
+pub mod sap_hana_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PhysicalPartitionsOfTable,
+        SapHanaDynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "excludeLastRequest", default, skip_serializing_if = "Option::is_none")]
+    pub exclude_last_request: Option<serde_json::Value>,
+    #[serde(rename = "baseRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub base_request_id: Option<serde_json::Value>,
+    #[serde(rename = "customRfcReadTableFunctionModule", default, skip_serializing_if = "Option::is_none")]
+    pub custom_rfc_read_table_function_module: Option<serde_json::Value>,
+    #[serde(rename = "sapDataColumnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub sap_data_column_delimiter: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "rowCount", default, skip_serializing_if = "Option::is_none")]
+    pub row_count: Option<serde_json::Value>,
+    #[serde(rename = "rowSkips", default, skip_serializing_if = "Option::is_none")]
+    pub row_skips: Option<serde_json::Value>,
+    #[serde(rename = "rfcTableFields", default, skip_serializing_if = "Option::is_none")]
+    pub rfc_table_fields: Option<serde_json::Value>,
+    #[serde(rename = "rfcTableOptions", default, skip_serializing_if = "Option::is_none")]
+    pub rfc_table_options: Option<serde_json::Value>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "customRfcReadTableFunctionModule", default, skip_serializing_if = "Option::is_none")]
+    pub custom_rfc_read_table_function_module: Option<serde_json::Value>,
+    #[serde(rename = "sapDataColumnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub sap_data_column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<sap_table_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SapTablePartitionSettings>,
+}
+pub mod sap_table_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PartitionOnInt,
+        PartitionOnCalendarYear,
+        PartitionOnCalendarMonth,
+        PartitionOnCalendarDate,
+        PartitionOnTime,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTablePartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+    #[serde(rename = "maxPartitionsNumber", default, skip_serializing_if = "Option::is_none")]
+    pub max_partitions_number: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "requestInterval", default, skip_serializing_if = "Option::is_none")]
+    pub request_interval: Option<serde_json::Value>,
+    #[serde(rename = "httpCompressionType", default, skip_serializing_if = "Option::is_none")]
+    pub http_compression_type: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "paginationRules", default, skip_serializing_if = "Option::is_none")]
+    pub pagination_rules: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "requestInterval", default, skip_serializing_if = "Option::is_none")]
+    pub request_interval: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "isolationLevel", default, skip_serializing_if = "Option::is_none")]
+    pub isolation_level: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlMiSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlDwSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSystemSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "distcpSettings", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_settings: Option<DistcpSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DistcpSettings {
+    #[serde(rename = "resourceManagerEndpoint")]
+    pub resource_manager_endpoint: serde_json::Value,
+    #[serde(rename = "tempScriptPath")]
+    pub temp_script_path: serde_json::Value,
+    #[serde(rename = "distcpOptions", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    pub query: serde_json::Value,
+    #[serde(rename = "noTruncation", default, skip_serializing_if = "Option::is_none")]
+    pub no_truncation: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "oracleReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub oracle_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<oracle_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<OraclePartitionSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+pub mod oracle_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PhysicalPartitionsOfTable,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OraclePartitionSettings {
+    #[serde(rename = "partitionNames", default, skip_serializing_if = "Option::is_none")]
+    pub partition_names: Option<serde_json::Value>,
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "oracleReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub oracle_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<AmazonRdsForOraclePartitionSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AmazonRdsForOraclePartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOraclePartitionSettings {
+    #[serde(rename = "partitionNames", default, skip_serializing_if = "Option::is_none")]
+    pub partition_names: Option<serde_json::Value>,
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<teradata_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<TeradataPartitionSettings>,
+}
+pub mod teradata_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        Hash,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "consistencyLevel", default, skip_serializing_if = "Option::is_none")]
+    pub consistency_level: Option<cassandra_source::ConsistencyLevel>,
+}
+pub mod cassandra_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ConsistencyLevel {
+        #[serde(rename = "ALL")]
+        All,
+        #[serde(rename = "EACH_QUORUM")]
+        EachQuorum,
+        #[serde(rename = "QUORUM")]
+        Quorum,
+        #[serde(rename = "LOCAL_QUORUM")]
+        LocalQuorum,
+        #[serde(rename = "ONE")]
+        One,
+        #[serde(rename = "TWO")]
+        Two,
+        #[serde(rename = "THREE")]
+        Three,
+        #[serde(rename = "LOCAL_ONE")]
+        LocalOne,
+        #[serde(rename = "SERIAL")]
+        Serial,
+        #[serde(rename = "LOCAL_SERIAL")]
+        LocalSerial,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2Source {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCursorMethodsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sort: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skip: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365Source {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "allowedGroups", default, skip_serializing_if = "Option::is_none")]
+    pub allowed_groups: Option<serde_json::Value>,
+    #[serde(rename = "userScopeFilterUri", default, skip_serializing_if = "Option::is_none")]
+    pub user_scope_filter_uri: Option<serde_json::Value>,
+    #[serde(rename = "dateFilterColumn", default, skip_serializing_if = "Option::is_none")]
+    pub date_filter_column: Option<serde_json::Value>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<serde_json::Value>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<serde_json::Value>,
+    #[serde(rename = "outputColumns", default, skip_serializing_if = "Option::is_none")]
+    pub output_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipHeaderLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_header_line_count: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQuerySource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifySource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<netezza_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<NetezzaPartitionSettings>,
+}
+pub mod netezza_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        DataSlice,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "redshiftUnloadSettings", default, skip_serializing_if = "Option::is_none")]
+    pub redshift_unload_settings: Option<RedshiftUnloadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedshiftUnloadSettings {
+    #[serde(rename = "s3LinkedServiceName")]
+    pub s3_linked_service_name: LinkedServiceReference,
+    #[serde(rename = "bucketName")]
+    pub bucket_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "exportSettings", default, skip_serializing_if = "Option::is_none")]
+    pub export_settings: Option<SnowflakeExportCopyCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExportSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeExportCopyCommand {
+    #[serde(flatten)]
+    pub export_settings: ExportSettings,
+    #[serde(rename = "additionalCopyOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_copy_options: Option<serde_json::Value>,
+    #[serde(rename = "additionalFormatOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_format_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "exportSettings", default, skip_serializing_if = "Option::is_none")]
+    pub export_settings: Option<AzureDatabricksDeltaLakeExportCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeExportCommand {
+    #[serde(flatten)]
+    pub export_settings: ExportSettings,
+    #[serde(rename = "dateFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_format: Option<serde_json::Value>,
+    #[serde(rename = "timestampFormat", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_format: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "importSettings", default, skip_serializing_if = "Option::is_none")]
+    pub import_settings: Option<AzureDatabricksDeltaLakeImportCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeImportCommand {
+    #[serde(flatten)]
+    pub import_settings: ImportSettings,
+    #[serde(rename = "dateFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_format: Option<serde_json::Value>,
+    #[serde(rename = "timestampFormat", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_format: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoredProcedureParameter {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<StoredProcedureParameterType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum StoredProcedureParameterType {
+    String,
+    Int,
+    Int64,
+    Decimal,
+    Guid,
+    Boolean,
+    Date,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopySink {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "writeBatchSize", default, skip_serializing_if = "Option::is_none")]
+    pub write_batch_size: Option<serde_json::Value>,
+    #[serde(rename = "writeBatchTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub write_batch_timeout: Option<serde_json::Value>,
+    #[serde(rename = "sinkRetryCount", default, skip_serializing_if = "Option::is_none")]
+    pub sink_retry_count: Option<serde_json::Value>,
+    #[serde(rename = "sinkRetryWait", default, skip_serializing_if = "Option::is_none")]
+    pub sink_retry_wait: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<sap_cloud_for_customer_sink::WriteBehavior>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+pub mod sap_cloud_for_customer_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Update,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureQueueSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum CopyBehaviorType {
+    PreserveHierarchy,
+    FlattenHierarchy,
+    MergeFiles,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "azureTableDefaultPartitionKeyValue", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_default_partition_key_value: Option<serde_json::Value>,
+    #[serde(rename = "azureTablePartitionKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_partition_key_name: Option<serde_json::Value>,
+    #[serde(rename = "azureTableRowKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_row_key_name: Option<serde_json::Value>,
+    #[serde(rename = "azureTableInsertType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_insert_type: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<AvroWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<ParquetWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinarySink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "blobWriterOverwriteFiles", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_overwrite_files: Option<serde_json::Value>,
+    #[serde(rename = "blobWriterDateTimeFormat", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_date_time_format: Option<serde_json::Value>,
+    #[serde(rename = "blobWriterAddHeader", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_add_header: Option<serde_json::Value>,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSystemSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlMiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlDwSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "allowPolyBase", default, skip_serializing_if = "Option::is_none")]
+    pub allow_poly_base: Option<serde_json::Value>,
+    #[serde(rename = "polyBaseSettings", default, skip_serializing_if = "Option::is_none")]
+    pub poly_base_settings: Option<PolybaseSettings>,
+    #[serde(rename = "allowCopyCommand", default, skip_serializing_if = "Option::is_none")]
+    pub allow_copy_command: Option<serde_json::Value>,
+    #[serde(rename = "copyCommandSettings", default, skip_serializing_if = "Option::is_none")]
+    pub copy_command_settings: Option<DwCopyCommandSettings>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolybaseSettings {
+    #[serde(rename = "rejectType", default, skip_serializing_if = "Option::is_none")]
+    pub reject_type: Option<PolybaseSettingsRejectType>,
+    #[serde(rename = "rejectValue", default, skip_serializing_if = "Option::is_none")]
+    pub reject_value: Option<serde_json::Value>,
+    #[serde(rename = "rejectSampleValue", default, skip_serializing_if = "Option::is_none")]
+    pub reject_sample_value: Option<serde_json::Value>,
+    #[serde(rename = "useTypeDefault", default, skip_serializing_if = "Option::is_none")]
+    pub use_type_default: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum PolybaseSettingsRejectType {
+    #[serde(rename = "value")]
+    Value,
+    #[serde(rename = "percentage")]
+    Percentage,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DwCopyCommandSettings {
+    #[serde(rename = "defaultValues", default, skip_serializing_if = "Vec::is_empty")]
+    pub default_values: Vec<DwCopyCommandDefaultValue>,
+    #[serde(rename = "additionalOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DwCopyCommandDefaultValue {
+    #[serde(rename = "columnName", default, skip_serializing_if = "Option::is_none")]
+    pub column_name: Option<serde_json::Value>,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "importSettings", default, skip_serializing_if = "Option::is_none")]
+    pub import_settings: Option<SnowflakeImportCopyCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeImportCopyCommand {
+    #[serde(flatten)]
+    pub import_settings: ImportSettings,
+    #[serde(rename = "additionalCopyOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_copy_options: Option<serde_json::Value>,
+    #[serde(rename = "additionalFormatOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_format_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogStorageSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
+    pub log_level: Option<serde_json::Value>,
+    #[serde(rename = "enableReliableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_reliable_logging: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogSettings {
+    #[serde(rename = "enableCopyActivityLog", default, skip_serializing_if = "Option::is_none")]
+    pub enable_copy_activity_log: Option<serde_json::Value>,
+    #[serde(rename = "copyActivityLogSettings", default, skip_serializing_if = "Option::is_none")]
+    pub copy_activity_log_settings: Option<CopyActivityLogSettings>,
+    #[serde(rename = "logLocationSettings")]
+    pub log_location_settings: LogLocationSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogLocationSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivityLogSettings {
+    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
+    pub log_level: Option<serde_json::Value>,
+    #[serde(rename = "enableReliableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_reliable_logging: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StagingSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+    #[serde(rename = "enableCompression", default, skip_serializing_if = "Option::is_none")]
+    pub enable_compression: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedirectIncompatibleRowSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SkipErrorFile {
+    #[serde(rename = "fileMissing", default, skip_serializing_if = "Option::is_none")]
+    pub file_missing: Option<serde_json::Value>,
+    #[serde(rename = "dataInconsistency", default, skip_serializing_if = "Option::is_none")]
+    pub data_inconsistency: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdditionalColumns {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+    #[serde(rename = "enableAdlsSingleFileParallel", default, skip_serializing_if = "Option::is_none")]
+    pub enable_adls_single_file_parallel: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<azure_search_index_sink::WriteBehavior>,
+}
+pub mod azure_search_index_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Merge,
+        Upload,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsSinkWriteBehavior {
+    Upsert,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "ingestionMappingName", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_mapping_name: Option<serde_json::Value>,
+    #[serde(rename = "ingestionMappingAsJson", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_mapping_as_json: Option<serde_json::Value>,
+    #[serde(rename = "flushImmediately", default, skip_serializing_if = "Option::is_none")]
+    pub flush_immediately: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<salesforce_sink::WriteBehavior>,
+    #[serde(rename = "externalIdFieldName", default, skip_serializing_if = "Option::is_none")]
+    pub external_id_field_name: Option<serde_json::Value>,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+}
+pub mod salesforce_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Upsert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<salesforce_service_cloud_sink::WriteBehavior>,
+    #[serde(rename = "externalIdFieldName", default, skip_serializing_if = "Option::is_none")]
+    pub external_id_field_name: Option<serde_json::Value>,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+}
+pub mod salesforce_service_cloud_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Upsert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyTranslator {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TabularTranslator {
+    #[serde(flatten)]
+    pub copy_translator: CopyTranslator,
+    #[serde(rename = "columnMappings", default, skip_serializing_if = "Option::is_none")]
+    pub column_mappings: Option<serde_json::Value>,
+    #[serde(rename = "schemaMapping", default, skip_serializing_if = "Option::is_none")]
+    pub schema_mapping: Option<serde_json::Value>,
+    #[serde(rename = "collectionReference", default, skip_serializing_if = "Option::is_none")]
+    pub collection_reference: Option<serde_json::Value>,
+    #[serde(rename = "mapComplexValuesToString", default, skip_serializing_if = "Option::is_none")]
+    pub map_complex_values_to_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mappings: Option<serde_json::Value>,
+    #[serde(rename = "typeConversion", default, skip_serializing_if = "Option::is_none")]
+    pub type_conversion: Option<serde_json::Value>,
+    #[serde(rename = "typeConversionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub type_conversion_settings: Option<TypeConversionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypeConversionSettings {
+    #[serde(rename = "allowDataTruncation", default, skip_serializing_if = "Option::is_none")]
+    pub allow_data_truncation: Option<serde_json::Value>,
+    #[serde(rename = "treatBooleanAsNumber", default, skip_serializing_if = "Option::is_none")]
+    pub treat_boolean_as_number: Option<serde_json::Value>,
+    #[serde(rename = "dateTimeFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_time_format: Option<serde_json::Value>,
+    #[serde(rename = "dateTimeOffsetFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_time_offset_format: Option<serde_json::Value>,
+    #[serde(rename = "timeSpanFormat", default, skip_serializing_if = "Option::is_none")]
+    pub time_span_format: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub culture: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightHiveActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightHiveActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightHiveActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "scriptPath", default, skip_serializing_if = "Option::is_none")]
+    pub script_path: Option<serde_json::Value>,
+    #[serde(rename = "scriptLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub script_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub variables: Vec<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum HdInsightActivityDebugInfoOption {
+    None,
+    Always,
+    Failure,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightPigActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightPigActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightPigActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub arguments: Option<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "scriptPath", default, skip_serializing_if = "Option::is_none")]
+    pub script_path: Option<serde_json::Value>,
+    #[serde(rename = "scriptLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub script_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightMapReduceActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightMapReduceActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightMapReduceActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "className")]
+    pub class_name: serde_json::Value,
+    #[serde(rename = "jarFilePath")]
+    pub jar_file_path: serde_json::Value,
+    #[serde(rename = "jarLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub jar_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "jarLibs", default, skip_serializing_if = "Vec::is_empty")]
+    pub jar_libs: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightStreamingActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightStreamingActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightStreamingActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    pub mapper: serde_json::Value,
+    pub reducer: serde_json::Value,
+    pub input: serde_json::Value,
+    pub output: serde_json::Value,
+    #[serde(rename = "filePaths")]
+    pub file_paths: Vec<serde_json::Value>,
+    #[serde(rename = "fileLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub file_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub combiner: Option<serde_json::Value>,
+    #[serde(rename = "commandEnvironment", default, skip_serializing_if = "Vec::is_empty")]
+    pub command_environment: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightSparkActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightSparkActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightSparkActivityTypeProperties {
+    #[serde(rename = "rootPath")]
+    pub root_path: serde_json::Value,
+    #[serde(rename = "entryFilePath")]
+    pub entry_file_path: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "sparkJobLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub spark_job_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(rename = "proxyUser", default, skip_serializing_if = "Option::is_none")]
+    pub proxy_user: Option<serde_json::Value>,
+    #[serde(rename = "sparkConfig", default, skip_serializing_if = "Option::is_none")]
+    pub spark_config: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteSsisPackageActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecuteSsisPackageActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteSsisPackageActivityTypeProperties {
+    #[serde(rename = "packageLocation")]
+    pub package_location: SsisPackageLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub runtime: Option<serde_json::Value>,
+    #[serde(rename = "loggingLevel", default, skip_serializing_if = "Option::is_none")]
+    pub logging_level: Option<serde_json::Value>,
+    #[serde(rename = "environmentPath", default, skip_serializing_if = "Option::is_none")]
+    pub environment_path: Option<serde_json::Value>,
+    #[serde(rename = "executionCredential", default, skip_serializing_if = "Option::is_none")]
+    pub execution_credential: Option<SsisExecutionCredential>,
+    #[serde(rename = "connectVia")]
+    pub connect_via: IntegrationRuntimeReference,
+    #[serde(rename = "projectParameters", default, skip_serializing_if = "Option::is_none")]
+    pub project_parameters: Option<serde_json::Value>,
+    #[serde(rename = "packageParameters", default, skip_serializing_if = "Option::is_none")]
+    pub package_parameters: Option<serde_json::Value>,
+    #[serde(rename = "projectConnectionManagers", default, skip_serializing_if = "Option::is_none")]
+    pub project_connection_managers: Option<serde_json::Value>,
+    #[serde(rename = "packageConnectionManagers", default, skip_serializing_if = "Option::is_none")]
+    pub package_connection_managers: Option<serde_json::Value>,
+    #[serde(rename = "propertyOverrides", default, skip_serializing_if = "Option::is_none")]
+    pub property_overrides: Option<serde_json::Value>,
+    #[serde(rename = "logLocation", default, skip_serializing_if = "Option::is_none")]
+    pub log_location: Option<SsisLogLocation>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPackageLocation {
+    #[serde(rename = "packagePath", default, skip_serializing_if = "Option::is_none")]
+    pub package_path: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<ssis_package_location::Type>,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SsisPackageLocationTypeProperties>,
+}
+pub mod ssis_package_location {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "SSISDB")]
+        Ssisdb,
+        File,
+        InlinePackage,
+        PackageStore,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPackageLocationTypeProperties {
+    #[serde(rename = "packagePassword", default, skip_serializing_if = "Option::is_none")]
+    pub package_password: Option<SecretBase>,
+    #[serde(rename = "accessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "configurationPath", default, skip_serializing_if = "Option::is_none")]
+    pub configuration_path: Option<serde_json::Value>,
+    #[serde(rename = "configurationAccessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub configuration_access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(rename = "packageContent", default, skip_serializing_if = "Option::is_none")]
+    pub package_content: Option<serde_json::Value>,
+    #[serde(rename = "packageLastModifiedDate", default, skip_serializing_if = "Option::is_none")]
+    pub package_last_modified_date: Option<String>,
+    #[serde(rename = "childPackages", default, skip_serializing_if = "Vec::is_empty")]
+    pub child_packages: Vec<SsisChildPackage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisConnectionManager {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisExecutionParameter {
+    pub value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPropertyOverride {
+    pub value: serde_json::Value,
+    #[serde(rename = "isSensitive", default, skip_serializing_if = "Option::is_none")]
+    pub is_sensitive: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisExecutionCredential {
+    pub domain: serde_json::Value,
+    #[serde(rename = "userName")]
+    pub user_name: serde_json::Value,
+    pub password: SecureString,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisAccessCredential {
+    pub domain: serde_json::Value,
+    #[serde(rename = "userName")]
+    pub user_name: serde_json::Value,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisChildPackage {
+    #[serde(rename = "packagePath")]
+    pub package_path: serde_json::Value,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(rename = "packageContent")]
+    pub package_content: serde_json::Value,
+    #[serde(rename = "packageLastModifiedDate", default, skip_serializing_if = "Option::is_none")]
+    pub package_last_modified_date: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisLogLocation {
+    #[serde(rename = "logPath")]
+    pub log_path: serde_json::Value,
+    #[serde(rename = "type")]
+    pub type_: ssis_log_location::Type,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SsisLogLocationTypeProperties,
+}
+pub mod ssis_log_location {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        File,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisLogLocationTypeProperties {
+    #[serde(rename = "accessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "logRefreshInterval", default, skip_serializing_if = "Option::is_none")]
+    pub log_refresh_interval: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CustomActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivityTypeProperties {
+    pub command: serde_json::Value,
+    #[serde(rename = "resourceLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub resource_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "referenceObjects", default, skip_serializing_if = "Option::is_none")]
+    pub reference_objects: Option<CustomActivityReferenceObject>,
+    #[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<serde_json::Value>,
+    #[serde(rename = "retentionTimeInDays", default, skip_serializing_if = "Option::is_none")]
+    pub retention_time_in_days: Option<serde_json::Value>,
+    #[serde(rename = "autoUserSpecification", default, skip_serializing_if = "Option::is_none")]
+    pub auto_user_specification: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivityReferenceObject {
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerStoredProcedureActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlServerStoredProcedureActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerStoredProcedureActivityTypeProperties {
+    #[serde(rename = "storedProcedureName")]
+    pub stored_procedure_name: serde_json::Value,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutePipelineActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecutePipelineActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutePipelineActivityTypeProperties {
+    pub pipeline: PipelineReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+    #[serde(rename = "waitOnCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub wait_on_completion: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DeleteActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteActivityTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<i64>,
+    #[serde(rename = "enableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_logging: Option<serde_json::Value>,
+    #[serde(rename = "logStorageSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_storage_settings: Option<LogStorageSettings>,
+    pub dataset: DatasetReference,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCommandActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerCommandActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCommandActivityTypeProperties {
+    pub command: serde_json::Value,
+    #[serde(rename = "commandTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub command_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LookupActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: LookupActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LookupActivityTypeProperties {
+    pub source: CopySource,
+    pub dataset: DatasetReference,
+    #[serde(rename = "firstRowOnly", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_only: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum WebActivityMethod {
+    #[serde(rename = "GET")]
+    Get,
+    #[serde(rename = "POST")]
+    Post,
+    #[serde(rename = "PUT")]
+    Put,
+    #[serde(rename = "DELETE")]
+    Delete,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivityAuthentication {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pfx: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivityTypeProperties {
+    pub method: WebActivityMethod,
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<WebActivityAuthentication>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetReference>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceReference>,
+    #[serde(rename = "connectVia", default, skip_serializing_if = "Option::is_none")]
+    pub connect_via: Option<IntegrationRuntimeReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetMetadataActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GetMetadataActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetMetadataActivityTypeProperties {
+    pub dataset: DatasetReference,
+    #[serde(rename = "fieldList", default, skip_serializing_if = "Vec::is_empty")]
+    pub field_list: Vec<serde_json::Value>,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<FormatReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IfConditionActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: IfConditionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IfConditionActivityTypeProperties {
+    pub expression: Expression,
+    #[serde(rename = "ifTrueActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub if_true_activities: Vec<Activity>,
+    #[serde(rename = "ifFalseActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub if_false_activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SwitchActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchActivityTypeProperties {
+    pub on: Expression,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub cases: Vec<SwitchCase>,
+    #[serde(rename = "defaultActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub default_activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchCase {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ForEachActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ForEachActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ForEachActivityTypeProperties {
+    #[serde(rename = "isSequential", default, skip_serializing_if = "Option::is_none")]
+    pub is_sequential: Option<bool>,
+    #[serde(rename = "batchCount", default, skip_serializing_if = "Option::is_none")]
+    pub batch_count: Option<i64>,
+    pub items: Expression,
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlBatchExecutionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlBatchExecutionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlBatchExecutionActivityTypeProperties {
+    #[serde(rename = "globalParameters", default, skip_serializing_if = "Option::is_none")]
+    pub global_parameters: Option<serde_json::Value>,
+    #[serde(rename = "webServiceOutputs", default, skip_serializing_if = "Option::is_none")]
+    pub web_service_outputs: Option<serde_json::Value>,
+    #[serde(rename = "webServiceInputs", default, skip_serializing_if = "Option::is_none")]
+    pub web_service_inputs: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlWebServiceFile {
+    #[serde(rename = "filePath")]
+    pub file_path: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlUpdateResourceActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlUpdateResourceActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlUpdateResourceActivityTypeProperties {
+    #[serde(rename = "trainedModelName")]
+    pub trained_model_name: serde_json::Value,
+    #[serde(rename = "trainedModelLinkedServiceName")]
+    pub trained_model_linked_service_name: LinkedServiceReference,
+    #[serde(rename = "trainedModelFilePath")]
+    pub trained_model_file_path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlExecutePipelineActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlExecutePipelineActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlExecutePipelineActivityTypeProperties {
+    #[serde(rename = "mlPipelineId")]
+    pub ml_pipeline_id: serde_json::Value,
+    #[serde(rename = "experimentName", default, skip_serializing_if = "Option::is_none")]
+    pub experiment_name: Option<serde_json::Value>,
+    #[serde(rename = "mlPipelineParameters", default, skip_serializing_if = "Option::is_none")]
+    pub ml_pipeline_parameters: Option<serde_json::Value>,
+    #[serde(rename = "mlParentRunId", default, skip_serializing_if = "Option::is_none")]
+    pub ml_parent_run_id: Option<serde_json::Value>,
+    #[serde(rename = "continueOnStepFailure", default, skip_serializing_if = "Option::is_none")]
+    pub continue_on_step_failure: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlPipelineParameters {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsUsqlActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DataLakeAnalyticsUsqlActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsUsqlActivityTypeProperties {
+    #[serde(rename = "scriptPath")]
+    pub script_path: serde_json::Value,
+    #[serde(rename = "scriptLinkedService")]
+    pub script_linked_service: LinkedServiceReference,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<serde_json::Value>,
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<serde_json::Value>,
+    #[serde(rename = "compilationMode", default, skip_serializing_if = "Option::is_none")]
+    pub compilation_mode: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WaitActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WaitActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WaitActivityTypeProperties {
+    #[serde(rename = "waitTimeInSeconds")]
+    pub wait_time_in_seconds: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UntilActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: UntilActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UntilActivityTypeProperties {
+    pub expression: Expression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ValidationActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ValidationActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ValidationActivityTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sleep: Option<serde_json::Value>,
+    #[serde(rename = "minimumSize", default, skip_serializing_if = "Option::is_none")]
+    pub minimum_size: Option<serde_json::Value>,
+    #[serde(rename = "childItems", default, skip_serializing_if = "Option::is_none")]
+    pub child_items: Option<serde_json::Value>,
+    pub dataset: DatasetReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FilterActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterActivityTypeProperties {
+    pub items: Expression,
+    pub condition: Expression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksNotebookActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksNotebookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksNotebookActivityTypeProperties {
+    #[serde(rename = "notebookPath")]
+    pub notebook_path: serde_json::Value,
+    #[serde(rename = "baseParameters", default, skip_serializing_if = "Option::is_none")]
+    pub base_parameters: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkJarActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksSparkJarActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkJarActivityTypeProperties {
+    #[serde(rename = "mainClassName")]
+    pub main_class_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkPythonActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksSparkPythonActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkPythonActivityTypeProperties {
+    #[serde(rename = "pythonFile")]
+    pub python_file: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetVariableActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SetVariableActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetVariableActivityTypeProperties {
+    #[serde(rename = "variableName", default, skip_serializing_if = "Option::is_none")]
+    pub variable_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppendVariableActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AppendVariableActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppendVariableActivityTypeProperties {
+    #[serde(rename = "variableName", default, skip_serializing_if = "Option::is_none")]
+    pub variable_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AzureFunctionActivityMethod {
+    #[serde(rename = "GET")]
+    Get,
+    #[serde(rename = "POST")]
+    Post,
+    #[serde(rename = "PUT")]
+    Put,
+    #[serde(rename = "DELETE")]
+    Delete,
+    #[serde(rename = "OPTIONS")]
+    Options,
+    #[serde(rename = "HEAD")]
+    Head,
+    #[serde(rename = "TRACE")]
+    Trace,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFunctionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionActivityTypeProperties {
+    pub method: AzureFunctionActivityMethod,
+    #[serde(rename = "functionName")]
+    pub function_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebHookActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebHookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum WebHookActivityMethod {
+    #[serde(rename = "POST")]
+    Post,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebHookActivityTypeProperties {
+    pub method: WebHookActivityMethod,
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<WebActivityAuthentication>,
+    #[serde(rename = "reportStatusOnCallBack", default, skip_serializing_if = "Option::is_none")]
+    pub report_status_on_call_back: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteDataFlowActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecuteDataFlowActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteDataFlowActivityTypeProperties {
+    pub dataflow: DataFlowReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<DataFlowStagingInfo>,
+    #[serde(rename = "integrationRuntime", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime: Option<IntegrationRuntimeReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<execute_data_flow_activity_type_properties::Compute>,
+    #[serde(rename = "traceLevel", default, skip_serializing_if = "Option::is_none")]
+    pub trace_level: Option<serde_json::Value>,
+    #[serde(rename = "continueOnError", default, skip_serializing_if = "Option::is_none")]
+    pub continue_on_error: Option<serde_json::Value>,
+    #[serde(rename = "runConcurrently", default, skip_serializing_if = "Option::is_none")]
+    pub run_concurrently: Option<serde_json::Value>,
+}
+pub mod execute_data_flow_activity_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Compute {
+        #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+        pub compute_type: Option<compute::ComputeType>,
+        #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+        pub core_count: Option<i64>,
+    }
+    pub mod compute {
+        use super::*;
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        pub enum ComputeType {
+            General,
+            MemoryOptimized,
+            ComputeOptimized,
+        }
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SqlPartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SapHanaPartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    SapHanaDynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SapTablePartitionOption {
+    None,
+    PartitionOnInt,
+    PartitionOnCalendarYear,
+    PartitionOnCalendarMonth,
+    PartitionOnCalendarDate,
+    PartitionOnTime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum OraclePartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TeradataPartitionOption {
+    None,
+    Hash,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum NetezzaPartitionOption {
+    None,
+    DataSlice,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SynapseNotebookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookActivityTypeProperties {
+    pub notebook: SynapseNotebookReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobDefinitionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SynapseSparkJobActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobActivityTypeProperties {
+    #[serde(rename = "sparkJob")]
+    pub spark_job: SynapseSparkJobReference,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolStoredProcedureActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+    #[serde(rename = "sqlPool")]
+    pub sql_pool: SqlPoolReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlPoolStoredProcedureActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolStoredProcedureActivityTypeProperties {
+    #[serde(rename = "storedProcedureName")]
+    pub stored_procedure_name: serde_json::Value,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinitionsListResponse {
+    pub value: Vec<SparkJobDefinitionResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinitionResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: SparkJobDefinition,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinition {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "targetBigDataPool")]
+    pub target_big_data_pool: BigDataPoolReference,
+    #[serde(rename = "requiredSparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub required_spark_version: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    #[serde(rename = "jobProperties")]
+    pub job_properties: SparkJobProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<spark_job_definition::Folder>,
+}
+pub mod spark_job_definition {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    pub file: String,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(rename = "driverMemory")]
+    pub driver_memory: String,
+    #[serde(rename = "driverCores")]
+    pub driver_cores: i64,
+    #[serde(rename = "executorMemory")]
+    pub executor_memory: String,
+    #[serde(rename = "executorCores")]
+    pub executor_cores: i64,
+    #[serde(rename = "numExecutors")]
+    pub num_executors: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptsListResponse {
+    pub value: Vec<SqlScriptResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    pub properties: SqlScript,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScript {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<sql_script::Type>,
+    pub content: SqlScriptContent,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<sql_script::Folder>,
+}
+pub mod sql_script {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlQuery,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptContent {
+    pub query: String,
+    #[serde(rename = "currentConnection", default, skip_serializing_if = "Option::is_none")]
+    pub current_connection: Option<SqlConnection>,
+    #[serde(rename = "resultLimit", default, skip_serializing_if = "Option::is_none")]
+    pub result_limit: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<SqlScriptMetadata>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptMetadata {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlConnection {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<sql_connection::Type>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "poolName", default, skip_serializing_if = "Option::is_none")]
+    pub pool_name: Option<String>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+}
+pub mod sql_connection {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlOnDemand,
+        SqlPool,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerListResponse {
+    pub value: Vec<TriggerResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Trigger,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRunsQueryResponse {
+    pub value: Vec<TriggerRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRun {
+    #[serde(rename = "triggerRunId", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_run_id: Option<String>,
+    #[serde(rename = "triggerName", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_name: Option<String>,
+    #[serde(rename = "triggerType", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_type: Option<String>,
+    #[serde(rename = "triggerRunTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_run_timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<trigger_run::Status>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(rename = "triggeredPipelines", default, skip_serializing_if = "Option::is_none")]
+    pub triggered_pipelines: Option<serde_json::Value>,
+}
+pub mod trigger_run {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Succeeded,
+        Failed,
+        Inprogress,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerSubscriptionOperationStatus {
+    #[serde(rename = "triggerName", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<trigger_subscription_operation_status::Status>,
+}
+pub mod trigger_subscription_operation_status {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Enabled,
+        Provisioning,
+        Deprovisioning,
+        Disabled,
+        Unknown,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureEntityResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Resource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceInfoListResult {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<BigDataPoolResourceInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceInfo {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<BigDataPoolResourceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceProperties {
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "autoScale", default, skip_serializing_if = "Option::is_none")]
+    pub auto_scale: Option<AutoScaleProperties>,
+    #[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
+    pub creation_date: Option<String>,
+    #[serde(rename = "autoPause", default, skip_serializing_if = "Option::is_none")]
+    pub auto_pause: Option<AutoPauseProperties>,
+    #[serde(rename = "isComputeIsolationEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_compute_isolation_enabled: Option<bool>,
+    #[serde(rename = "sessionLevelPackagesEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub session_level_packages_enabled: Option<bool>,
+    #[serde(rename = "cacheSize", default, skip_serializing_if = "Option::is_none")]
+    pub cache_size: Option<i32>,
+    #[serde(rename = "dynamicExecutorAllocation", default, skip_serializing_if = "Option::is_none")]
+    pub dynamic_executor_allocation: Option<DynamicExecutorAllocation>,
+    #[serde(rename = "sparkEventsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub spark_events_folder: Option<String>,
+    #[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub node_count: Option<i32>,
+    #[serde(rename = "libraryRequirements", default, skip_serializing_if = "Option::is_none")]
+    pub library_requirements: Option<LibraryRequirements>,
+    #[serde(rename = "customLibraries", default, skip_serializing_if = "Vec::is_empty")]
+    pub custom_libraries: Vec<LibraryInfo>,
+    #[serde(rename = "sparkConfigProperties", default, skip_serializing_if = "Option::is_none")]
+    pub spark_config_properties: Option<LibraryRequirements>,
+    #[serde(rename = "sparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub spark_version: Option<String>,
+    #[serde(rename = "defaultSparkLogFolder", default, skip_serializing_if = "Option::is_none")]
+    pub default_spark_log_folder: Option<String>,
+    #[serde(rename = "nodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub node_size: Option<big_data_pool_resource_properties::NodeSize>,
+    #[serde(rename = "nodeSizeFamily", default, skip_serializing_if = "Option::is_none")]
+    pub node_size_family: Option<big_data_pool_resource_properties::NodeSizeFamily>,
+    #[serde(rename = "lastSucceededTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub last_succeeded_timestamp: Option<String>,
+}
+pub mod big_data_pool_resource_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum NodeSize {
+        None,
+        Small,
+        Medium,
+        Large,
+        XLarge,
+        #[serde(rename = "XXLarge")]
+        XxLarge,
+        #[serde(rename = "XXXLarge")]
+        XxxLarge,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum NodeSizeFamily {
+        None,
+        MemoryOptimized,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AutoScaleProperties {
+    #[serde(rename = "minNodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub min_node_count: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(rename = "maxNodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub max_node_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AutoPauseProperties {
+    #[serde(rename = "delayInMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub delay_in_minutes: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicExecutorAllocation {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryRequirements {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filename: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "containerName", default, skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+    #[serde(rename = "uploadedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub uploaded_timestamp: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<String>,
+    #[serde(rename = "creatorId", default, skip_serializing_if = "Option::is_none")]
+    pub creator_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TrackedResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub location: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorResponse>,
+    #[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_info: Vec<ErrorAdditionalInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorAdditionalInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntime {
+    #[serde(rename = "type")]
+    pub type_: IntegrationRuntimeType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum IntegrationRuntimeType {
+    Managed,
+    SelfHosted,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeListResponse {
+    pub value: Vec<IntegrationRuntimeResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: IntegrationRuntime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJob {
+    #[serde(rename = "livyInfo", default, skip_serializing_if = "Option::is_none")]
+    pub livy_info: Option<SparkBatchJobState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "workspaceName", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_name: Option<String>,
+    #[serde(rename = "sparkPoolName", default, skip_serializing_if = "Option::is_none")]
+    pub spark_pool_name: Option<String>,
+    #[serde(rename = "submitterName", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_name: Option<String>,
+    #[serde(rename = "submitterId", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<spark_batch_job::JobType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<spark_batch_job::Result>,
+    #[serde(rename = "schedulerInfo", default, skip_serializing_if = "Option::is_none")]
+    pub scheduler_info: Option<SparkScheduler>,
+    #[serde(rename = "pluginInfo", default, skip_serializing_if = "Option::is_none")]
+    pub plugin_info: Option<SparkServicePlugin>,
+    #[serde(rename = "errorInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_info: Vec<SparkServiceError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub id: i32,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appInfo", default, skip_serializing_if = "Option::is_none")]
+    pub app_info: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<spark_batch_job::State>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub log: Vec<String>,
+}
+pub mod spark_batch_job {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum JobType {
+        SparkBatch,
+        SparkSession,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        Uncertain,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        #[serde(rename = "not_started")]
+        NotStarted,
+        #[serde(rename = "starting")]
+        Starting,
+        #[serde(rename = "idle")]
+        Idle,
+        #[serde(rename = "busy")]
+        Busy,
+        #[serde(rename = "shutting_down")]
+        ShuttingDown,
+        #[serde(rename = "error")]
+        Error,
+        #[serde(rename = "dead")]
+        Dead,
+        #[serde(rename = "killed")]
+        Killed,
+        #[serde(rename = "success")]
+        Success,
+        #[serde(rename = "running")]
+        Running,
+        #[serde(rename = "recovering")]
+        Recovering,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobState {
+    #[serde(rename = "notStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub not_started_at: Option<String>,
+    #[serde(rename = "startingAt", default, skip_serializing_if = "Option::is_none")]
+    pub starting_at: Option<String>,
+    #[serde(rename = "runningAt", default, skip_serializing_if = "Option::is_none")]
+    pub running_at: Option<String>,
+    #[serde(rename = "deadAt", default, skip_serializing_if = "Option::is_none")]
+    pub dead_at: Option<String>,
+    #[serde(rename = "successAt", default, skip_serializing_if = "Option::is_none")]
+    pub success_at: Option<String>,
+    #[serde(rename = "killedAt", default, skip_serializing_if = "Option::is_none")]
+    pub killed_at: Option<String>,
+    #[serde(rename = "recoveringAt", default, skip_serializing_if = "Option::is_none")]
+    pub recovering_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+    #[serde(rename = "jobCreationRequest", default, skip_serializing_if = "Option::is_none")]
+    pub job_creation_request: Option<SparkRequest>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub file: Option<String>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkScheduler {
+    #[serde(rename = "submittedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submitted_at: Option<String>,
+    #[serde(rename = "scheduledAt", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_at: Option<String>,
+    #[serde(rename = "endedAt", default, skip_serializing_if = "Option::is_none")]
+    pub ended_at: Option<String>,
+    #[serde(rename = "cancellationRequestedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_requested_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_scheduler::CurrentState>,
+}
+pub mod spark_scheduler {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Queued,
+        Scheduled,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServicePlugin {
+    #[serde(rename = "preparationStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub preparation_started_at: Option<String>,
+    #[serde(rename = "resourceAcquisitionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub resource_acquisition_started_at: Option<String>,
+    #[serde(rename = "submissionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submission_started_at: Option<String>,
+    #[serde(rename = "monitoringStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub monitoring_started_at: Option<String>,
+    #[serde(rename = "cleanupStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cleanup_started_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_service_plugin::CurrentState>,
+}
+pub mod spark_service_plugin {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Preparation,
+        ResourceAcquisition,
+        Queued,
+        Submission,
+        Monitoring,
+        Cleanup,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServiceError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<spark_service_error::Source>,
+}
+pub mod spark_service_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Source {
+        System,
+        User,
+        Unknown,
+        Dependency,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolInfoListResult {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<SqlPool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPool {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<Sku>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<SqlPoolResourceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Sku {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tier: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub capacity: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolResourceProperties {
+    #[serde(rename = "maxSizeBytes", default, skip_serializing_if = "Option::is_none")]
+    pub max_size_bytes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collation: Option<String>,
+    #[serde(rename = "sourceDatabaseId", default, skip_serializing_if = "Option::is_none")]
+    pub source_database_id: Option<String>,
+    #[serde(rename = "recoverableDatabaseId", default, skip_serializing_if = "Option::is_none")]
+    pub recoverable_database_id: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "restorePointInTime", default, skip_serializing_if = "Option::is_none")]
+    pub restore_point_in_time: Option<String>,
+    #[serde(rename = "createMode", default, skip_serializing_if = "Option::is_none")]
+    pub create_mode: Option<sql_pool_resource_properties::CreateMode>,
+    #[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
+    pub creation_date: Option<String>,
+}
+pub mod sql_pool_resource_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CreateMode {
+        Default,
+        PointInTimeRestore,
+        Recovery,
+        Restore,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Workspace {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<WorkspaceProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<ManagedIdentity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceProperties {
+    #[serde(rename = "defaultDataLakeStorage", default, skip_serializing_if = "Option::is_none")]
+    pub default_data_lake_storage: Option<DataLakeStorageAccountDetails>,
+    #[serde(rename = "sqlAdministratorLoginPassword", default, skip_serializing_if = "Option::is_none")]
+    pub sql_administrator_login_password: Option<String>,
+    #[serde(rename = "managedResourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub managed_resource_group_name: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "sqlAdministratorLogin", default, skip_serializing_if = "Option::is_none")]
+    pub sql_administrator_login: Option<String>,
+    #[serde(rename = "virtualNetworkProfile", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_network_profile: Option<VirtualNetworkProfile>,
+    #[serde(rename = "connectivityEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub connectivity_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "managedVirtualNetwork", default, skip_serializing_if = "Option::is_none")]
+    pub managed_virtual_network: Option<String>,
+    #[serde(rename = "privateEndpointConnections", default, skip_serializing_if = "Vec::is_empty")]
+    pub private_endpoint_connections: Vec<PrivateEndpointConnection>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encryption: Option<EncryptionDetails>,
+    #[serde(rename = "workspaceUID", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_uid: Option<String>,
+    #[serde(rename = "extraProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extra_properties: Option<serde_json::Value>,
+    #[serde(rename = "managedVirtualNetworkSettings", default, skip_serializing_if = "Option::is_none")]
+    pub managed_virtual_network_settings: Option<ManagedVirtualNetworkSettings>,
+    #[serde(rename = "workspaceRepositoryConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_repository_configuration: Option<WorkspaceRepositoryConfiguration>,
+    #[serde(rename = "purviewConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub purview_configuration: Option<PurviewConfiguration>,
+    #[serde(rename = "adlaResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub adla_resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeStorageAccountDetails {
+    #[serde(rename = "accountUrl", default, skip_serializing_if = "Option::is_none")]
+    pub account_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filesystem: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualNetworkProfile {
+    #[serde(rename = "computeSubnetId", default, skip_serializing_if = "Option::is_none")]
+    pub compute_subnet_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpointConnection {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<PrivateEndpointConnectionProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpointConnectionProperties {
+    #[serde(rename = "privateEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub private_endpoint: Option<PrivateEndpoint>,
+    #[serde(rename = "privateLinkServiceConnectionState", default, skip_serializing_if = "Option::is_none")]
+    pub private_link_service_connection_state: Option<PrivateLinkServiceConnectionState>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpoint {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateLinkServiceConnectionState {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "actionsRequired", default, skip_serializing_if = "Option::is_none")]
+    pub actions_required: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProxyResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionDetails {
+    #[serde(rename = "doubleEncryptionEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub double_encryption_enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cmk: Option<CustomerManagedKeyDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomerManagedKeyDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<WorkspaceKeyDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceKeyDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "keyVaultUrl", default, skip_serializing_if = "Option::is_none")]
+    pub key_vault_url: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedVirtualNetworkSettings {
+    #[serde(rename = "preventDataExfiltration", default, skip_serializing_if = "Option::is_none")]
+    pub prevent_data_exfiltration: Option<bool>,
+    #[serde(rename = "linkedAccessCheckOnTargetResource", default, skip_serializing_if = "Option::is_none")]
+    pub linked_access_check_on_target_resource: Option<bool>,
+    #[serde(rename = "allowedAadTenantIdsForLinking", default, skip_serializing_if = "Vec::is_empty")]
+    pub allowed_aad_tenant_ids_for_linking: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceRepositoryConfiguration {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<String>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<String>,
+    #[serde(rename = "projectName", default, skip_serializing_if = "Option::is_none")]
+    pub project_name: Option<String>,
+    #[serde(rename = "repositoryName", default, skip_serializing_if = "Option::is_none")]
+    pub repository_name: Option<String>,
+    #[serde(rename = "collaborationBranch", default, skip_serializing_if = "Option::is_none")]
+    pub collaboration_branch: Option<String>,
+    #[serde(rename = "rootFolder", default, skip_serializing_if = "Option::is_none")]
+    pub root_folder: Option<String>,
+    #[serde(rename = "lastCommitId", default, skip_serializing_if = "Option::is_none")]
+    pub last_commit_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<GitHubClientSecret>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubClientSecret {
+    #[serde(rename = "byoaSecretAkvUrl", default, skip_serializing_if = "Option::is_none")]
+    pub byoa_secret_akv_url: Option<String>,
+    #[serde(rename = "byoaSecretName", default, skip_serializing_if = "Option::is_none")]
+    pub byoa_secret_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PurviewConfiguration {
+    #[serde(rename = "purviewResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub purview_resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedIdentity {
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<managed_identity::Type>,
+}
+pub mod managed_identity {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        None,
+        SystemAssigned,
+    }
+}
diff --git a/services/svc/synapse/src/package_artifacts_2020_12_01/operations.rs b/services/svc/synapse/src/package_artifacts_2020_12_01/operations.rs
new file mode 100644
index 0000000000..db58140159
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2020_12_01/operations.rs
@@ -0,0 +1,5364 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod big_data_pools {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<BigDataPoolResourceInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/bigDataPools", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BigDataPoolResourceInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        big_data_pool_name: &str,
+    ) -> std::result::Result<BigDataPoolResourceInfo, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/bigDataPools/{}", operation_config.base_path(), big_data_pool_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BigDataPoolResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_flow {
+    use crate::models::*;
+    pub async fn get_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<DataFlowResource, get_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(get_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        if_match: Option<&str>,
+        data_flow: &DataFlowResource,
+    ) -> std::result::Result<create_or_update_data_flow::Response, create_or_update_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(data_flow).map_err(create_or_update_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_data_flow::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_data_flow::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DataFlowResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+    ) -> std::result::Result<delete_data_flow::Response, delete_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_data_flow::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_data_flow::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_data_flow::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_data_flow::Response, rename_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}/rename", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_data_flow::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_data_flow::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_data_flows_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<DataFlowListResponse, get_data_flows_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_data_flows_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_data_flows_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_data_flows_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_data_flows_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_data_flows_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_data_flows_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_data_flows_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_data_flows_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_flow_debug_session {
+    use crate::models::*;
+    pub async fn create_data_flow_debug_session(
+        operation_config: &crate::OperationConfig,
+        request: &CreateDataFlowDebugSessionRequest,
+    ) -> std::result::Result<create_data_flow_debug_session::Response, create_data_flow_debug_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/createDataFlowDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(create_data_flow_debug_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_data_flow_debug_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(create_data_flow_debug_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_data_flow_debug_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_data_flow_debug_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(create_data_flow_debug_session::Response::Accepted202),
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: CreateDataFlowDebugSessionResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_data_flow_debug_session::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_data_flow_debug_session::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_data_flow_debug_session {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            Ok200(CreateDataFlowDebugSessionResponse),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_data_flow_debug_sessions_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<QueryDataFlowDebugSessionsResponse, query_data_flow_debug_sessions_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryDataFlowDebugSessions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_data_flow_debug_sessions_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_data_flow_debug_sessions_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_data_flow_debug_sessions_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_data_flow_debug_sessions_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryDataFlowDebugSessionsResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_data_flow_debug_sessions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_data_flow_debug_sessions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_data_flow_debug_sessions_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_data_flow_debug_sessions_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_data_flow(
+        operation_config: &crate::OperationConfig,
+        request: &DataFlowDebugPackage,
+    ) -> std::result::Result<AddDataFlowToDebugSessionResponse, add_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/addDataFlowToDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(add_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(add_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AddDataFlowToDebugSessionResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_data_flow_debug_session(
+        operation_config: &crate::OperationConfig,
+        request: &DeleteDataFlowDebugSessionRequest,
+    ) -> std::result::Result<(), delete_data_flow_debug_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deleteDataFlowDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(delete_data_flow_debug_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_data_flow_debug_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(delete_data_flow_debug_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_data_flow_debug_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_data_flow_debug_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_data_flow_debug_session::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_data_flow_debug_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_command(
+        operation_config: &crate::OperationConfig,
+        request: &DataFlowDebugCommandRequest,
+    ) -> std::result::Result<execute_command::Response, execute_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/executeDataFlowDebugCommand", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(execute_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(execute_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(execute_command::Response::Accepted202),
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowDebugCommandResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_command::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_command::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_command {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            Ok200(DataFlowDebugCommandResponse),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod dataset {
+    use crate::models::*;
+    pub async fn get_datasets_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<DatasetListResponse, get_datasets_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_datasets_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_datasets_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_datasets_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_datasets_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_datasets_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_datasets_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_datasets_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_datasets_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<DatasetResource, get_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(get_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_dataset::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        if_match: Option<&str>,
+        dataset: &DatasetResource,
+    ) -> std::result::Result<create_or_update_dataset::Response, create_or_update_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(dataset).map_err(create_or_update_dataset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_dataset::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_dataset::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DatasetResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+    ) -> std::result::Result<delete_dataset::Response, delete_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_dataset::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_dataset::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_dataset::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_dataset::Response, rename_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}/rename", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_dataset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_dataset::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_dataset::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| rename_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod linked_service {
+    use crate::models::*;
+    pub async fn get_linked_services_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<LinkedServiceListResponse, get_linked_services_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_linked_services_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_linked_services_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_linked_services_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_linked_services_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_services_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_services_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_linked_services_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_linked_services_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<LinkedServiceResource, get_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(get_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_linked_service::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        if_match: Option<&str>,
+        linked_service: &LinkedServiceResource,
+    ) -> std::result::Result<create_or_update_linked_service::Response, create_or_update_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(linked_service).map_err(create_or_update_linked_service::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_linked_service::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_linked_service::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(LinkedServiceResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+    ) -> std::result::Result<delete_linked_service::Response, delete_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_linked_service::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_linked_service::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_linked_service::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_linked_service::Response, rename_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}/rename", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_linked_service::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_linked_service::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_linked_service::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod workspace_git_repo_management {
+    use crate::models::*;
+    pub async fn get_git_hub_access_token(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+        git_hub_access_token_request: &GitHubAccessTokenRequest,
+    ) -> std::result::Result<GitHubAccessTokenResponse, get_git_hub_access_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/getGitHubAccessToken", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_git_hub_access_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_git_hub_access_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        let req_body = azure_core::to_json(git_hub_access_token_request).map_err(get_git_hub_access_token::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_git_hub_access_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_git_hub_access_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GitHubAccessTokenResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_git_hub_access_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_git_hub_access_token::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_git_hub_access_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod integration_runtimes {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<IntegrationRuntimeListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/integrationRuntimes", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IntegrationRuntimeListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        integration_runtime_name: &str,
+    ) -> std::result::Result<IntegrationRuntimeResource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/integrationRuntimes/{}", operation_config.base_path(), integration_runtime_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IntegrationRuntimeResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod library {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<LibraryListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn flush(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<flush::Response, flush::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}/flush", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(flush::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(flush::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(flush::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(flush::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(flush::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| flush::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(flush::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| flush::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(flush::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod flush {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_operation_result(
+        operation_config: &crate::OperationConfig,
+        operation_id: &str,
+    ) -> std::result::Result<get_operation_result::Response, get_operation_result::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraryOperationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get_operation_result::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_operation_result::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_operation_result::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_operation_result::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(get_operation_result::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: OperationResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(get_operation_result::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_operation_result::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_operation_result {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(LibraryResource),
+            Accepted202(OperationResult),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, library_name: &str) -> std::result::Result<LibraryResource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<create::Response, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(create::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::CONFLICT => Err(delete::Error::Conflict409 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Conflict409 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod notebook {
+    use crate::models::*;
+    pub async fn get_notebooks_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<NotebookListResponse, get_notebooks_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_notebooks_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebooks_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_notebooks_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebooks_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebooks_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebooks_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebooks_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebooks_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_notebook_summary_by_work_space(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<NotebookListResponse, get_notebook_summary_by_work_space::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooksSummary", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_notebook_summary_by_work_space::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebook_summary_by_work_space::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_notebook_summary_by_work_space::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebook_summary_by_work_space::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebook_summary_by_work_space::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebook_summary_by_work_space::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebook_summary_by_work_space::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebook_summary_by_work_space {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<NotebookResource, get_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(get_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_notebook::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        if_match: Option<&str>,
+        notebook: &NotebookResource,
+    ) -> std::result::Result<create_or_update_notebook::Response, create_or_update_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(notebook).map_err(create_or_update_notebook::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_notebook::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_notebook::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(NotebookResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+    ) -> std::result::Result<delete_notebook::Response, delete_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_notebook::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_notebook::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_notebook::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_notebook::Response, rename_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}/rename", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_notebook::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_notebook::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_notebook::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod notebook_operation_result {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, operation_id: &str) -> std::result::Result<get::Response, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebookOperationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(get::Response::Ok200),
+            http::StatusCode::CREATED => Ok(get::Response::Created201),
+            http::StatusCode::ACCEPTED => Ok(get::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(get::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Created201,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod operation_result {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, operation_id: &str) -> std::result::Result<get::Response, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/operationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(get::Response::Ok200),
+            http::StatusCode::CREATED => Ok(get::Response::Created201),
+            http::StatusCode::ACCEPTED => Ok(get::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(get::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Created201,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod operation_status {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, operation_id: &str) -> std::result::Result<get::Response, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/operationStatuses/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(get::Response::Ok200),
+            http::StatusCode::CREATED => Ok(get::Response::Created201),
+            http::StatusCode::ACCEPTED => Ok(get::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(get::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Created201,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline {
+    use crate::models::*;
+    pub async fn get_pipelines_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<PipelineListResponse, get_pipelines_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_pipelines_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipelines_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_pipelines_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipelines_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipelines_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipelines_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipelines_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipelines_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<PipelineResource, get_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(get_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_pipeline::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        if_match: Option<&str>,
+        pipeline: &PipelineResource,
+    ) -> std::result::Result<create_or_update_pipeline::Response, create_or_update_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(pipeline).map_err(create_or_update_pipeline::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_pipeline::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_pipeline::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(PipelineResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+    ) -> std::result::Result<delete_pipeline::Response, delete_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_pipeline::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_pipeline::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_pipeline::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_pipeline::Response, rename_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}/rename", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_pipeline::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_pipeline::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_pipeline::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        reference_pipeline_run_id: Option<&str>,
+        is_recovery: Option<bool>,
+        start_activity_name: Option<&str>,
+        parameters: Option<&ParameterValueSpecification>,
+    ) -> std::result::Result<CreateRunResponse, create_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}/createRun", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(create_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(reference_pipeline_run_id) = reference_pipeline_run_id {
+            url.query_pairs_mut()
+                .append_pair("referencePipelineRunId", reference_pipeline_run_id);
+        }
+        if let Some(is_recovery) = is_recovery {
+            url.query_pairs_mut().append_pair("isRecovery", is_recovery.to_string().as_str());
+        }
+        if let Some(start_activity_name) = start_activity_name {
+            url.query_pairs_mut().append_pair("startActivityName", start_activity_name);
+        }
+        let req_body = if let Some(parameters) = parameters {
+            azure_core::to_json(parameters).map_err(create_pipeline_run::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: CreateRunResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline_run {
+    use crate::models::*;
+    pub async fn query_pipeline_runs_by_workspace(
+        operation_config: &crate::OperationConfig,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<PipelineRunsQueryResponse, query_pipeline_runs_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryPipelineRuns", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_pipeline_runs_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_pipeline_runs_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_pipeline_runs_by_workspace::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_pipeline_runs_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_pipeline_runs_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_pipeline_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_pipeline_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_pipeline_runs_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_pipeline_runs_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        run_id: &str,
+    ) -> std::result::Result<PipelineRun, get_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelineruns/{}", operation_config.base_path(), run_id);
+        let mut url = url::Url::parse(url_str).map_err(get_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineRun = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_activity_runs(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        run_id: &str,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<ActivityRunsQueryResponse, query_activity_runs::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/pipelines/{}/pipelineruns/{}/queryActivityruns",
+            operation_config.base_path(),
+            pipeline_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(query_activity_runs::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_activity_runs::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_activity_runs::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query_activity_runs::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_activity_runs::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ActivityRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_activity_runs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_activity_runs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_activity_runs::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_activity_runs {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        run_id: &str,
+        is_recursive: Option<bool>,
+    ) -> std::result::Result<(), cancel_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelineruns/{}/cancel", operation_config.base_path(), run_id);
+        let mut url = url::Url::parse(url_str).map_err(cancel_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(is_recursive) = is_recursive {
+            url.query_pairs_mut().append_pair("isRecursive", is_recursive.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod spark_job_definition {
+    use crate::models::*;
+    pub async fn get_spark_job_definitions_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SparkJobDefinitionsListResponse, get_spark_job_definitions_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_definitions_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_definitions_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_job_definitions_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_definitions_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definitions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definitions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_job_definitions_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_definitions_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SparkJobDefinitionResource, get_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_spark_job_definition::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        if_match: Option<&str>,
+        spark_job_definition: &SparkJobDefinitionResource,
+    ) -> std::result::Result<create_or_update_spark_job_definition::Response, create_or_update_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(spark_job_definition).map_err(create_or_update_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_spark_job_definition::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SparkJobDefinitionResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+    ) -> std::result::Result<delete_spark_job_definition::Response, delete_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_spark_job_definition::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_spark_job_definition::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_spark_job_definition::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+    ) -> std::result::Result<execute_spark_job_definition::Response, execute_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkJobDefinitions/{}/execute",
+            operation_config.base_path(),
+            spark_job_definition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(execute_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(execute_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_spark_job_definition::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202(SparkBatchJob),
+            Ok200(SparkBatchJob),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_spark_job_definition::Response, rename_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkJobDefinitions/{}/rename",
+            operation_config.base_path(),
+            spark_job_definition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(rename_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_spark_job_definition::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_spark_job_definition::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn debug_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_azure_resource: &SparkJobDefinitionResource,
+    ) -> std::result::Result<debug_spark_job_definition::Response, debug_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/debugSparkJobDefinition", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(debug_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(debug_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body =
+            azure_core::to_json(spark_job_definition_azure_resource).map_err(debug_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(debug_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(debug_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(debug_spark_job_definition::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(debug_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(debug_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod debug_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202(SparkBatchJob),
+            Ok200(SparkBatchJob),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod sql_pools {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<SqlPoolInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlPools", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlPoolInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, sql_pool_name: &str) -> std::result::Result<SqlPool, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlPools/{}", operation_config.base_path(), sql_pool_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlPool =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod sql_script {
+    use crate::models::*;
+    pub async fn get_sql_scripts_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SqlScriptsListResponse, get_sql_scripts_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_scripts_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_scripts_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_sql_scripts_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_scripts_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_scripts_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_scripts_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_sql_scripts_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_sql_scripts_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SqlScriptResource, get_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_sql_script::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        if_match: Option<&str>,
+        sql_script: &SqlScriptResource,
+    ) -> std::result::Result<create_or_update_sql_script::Response, create_or_update_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(sql_script).map_err(create_or_update_sql_script::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_sql_script::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_sql_script::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SqlScriptResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+    ) -> std::result::Result<delete_sql_script::Response, delete_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_sql_script::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_sql_script::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_sql_script::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_sql_script::Response, rename_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}/rename", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_sql_script::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_sql_script::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_sql_script::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod trigger {
+    use crate::models::*;
+    pub async fn get_triggers_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<TriggerListResponse, get_triggers_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_triggers_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_triggers_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_triggers_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_triggers_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_triggers_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_triggers_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_triggers_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_triggers_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<TriggerResource, get_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(get_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_trigger::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        if_match: Option<&str>,
+        trigger: &TriggerResource,
+    ) -> std::result::Result<create_or_update_trigger::Response, create_or_update_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(trigger).map_err(create_or_update_trigger::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_trigger::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_trigger::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<delete_trigger::Response, delete_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_trigger::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_trigger::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_trigger::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn subscribe_trigger_to_events(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<subscribe_trigger_to_events::Response, subscribe_trigger_to_events::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/subscribeToEvents", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(subscribe_trigger_to_events::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(subscribe_trigger_to_events::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(subscribe_trigger_to_events::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(subscribe_trigger_to_events::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| subscribe_trigger_to_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(subscribe_trigger_to_events::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(subscribe_trigger_to_events::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| subscribe_trigger_to_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(subscribe_trigger_to_events::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod subscribe_trigger_to_events {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerSubscriptionOperationStatus),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_event_subscription_status(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<TriggerSubscriptionOperationStatus, get_event_subscription_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/getEventSubscriptionStatus",
+            operation_config.base_path(),
+            trigger_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_event_subscription_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_event_subscription_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_event_subscription_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_event_subscription_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_subscription_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_subscription_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_event_subscription_status::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_event_subscription_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn unsubscribe_trigger_from_events(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<unsubscribe_trigger_from_events::Response, unsubscribe_trigger_from_events::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/unsubscribeFromEvents", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(unsubscribe_trigger_from_events::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(unsubscribe_trigger_from_events::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(unsubscribe_trigger_from_events::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(unsubscribe_trigger_from_events::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| unsubscribe_trigger_from_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(unsubscribe_trigger_from_events::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(unsubscribe_trigger_from_events::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| unsubscribe_trigger_from_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(unsubscribe_trigger_from_events::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod unsubscribe_trigger_from_events {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerSubscriptionOperationStatus),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn start_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<(), start_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/start", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(start_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(start_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(start_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(start_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| start_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(start_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod start_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn stop_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<(), stop_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/stop", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(stop_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(stop_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(stop_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(stop_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| stop_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(stop_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod stop_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod trigger_run {
+    use crate::models::*;
+    pub async fn rerun_trigger_instance(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<(), rerun_trigger_instance::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/triggerRuns/{}/rerun",
+            operation_config.base_path(),
+            trigger_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(rerun_trigger_instance::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rerun_trigger_instance::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rerun_trigger_instance::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rerun_trigger_instance::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rerun_trigger_instance::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rerun_trigger_instance::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rerun_trigger_instance {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_trigger_instance(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<(), cancel_trigger_instance::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/triggerRuns/{}/cancel",
+            operation_config.base_path(),
+            trigger_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_trigger_instance::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_trigger_instance::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(cancel_trigger_instance::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_trigger_instance::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_trigger_instance::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_trigger_instance::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_trigger_instance {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_trigger_runs_by_workspace(
+        operation_config: &crate::OperationConfig,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<TriggerRunsQueryResponse, query_trigger_runs_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryTriggerRuns", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_trigger_runs_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_trigger_runs_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_trigger_runs_by_workspace::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_trigger_runs_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_trigger_runs_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_trigger_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_trigger_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_trigger_runs_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_trigger_runs_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod workspace {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig) -> std::result::Result<Workspace, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/workspace", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Workspace =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_artifacts_2021_06_01_preview/mod.rs b/services/svc/synapse/src/package_artifacts_2021_06_01_preview/mod.rs
new file mode 100644
index 0000000000..ed72a17404
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2021_06_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-06-01-preview";
diff --git a/services/svc/synapse/src/package_artifacts_2021_06_01_preview/models.rs b/services/svc/synapse/src/package_artifacts_2021_06_01_preview/models.rs
new file mode 100644
index 0000000000..4443e25c2a
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2021_06_01_preview/models.rs
@@ -0,0 +1,9454 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubResource {
+    #[serde(flatten)]
+    pub azure_entity_resource: AzureEntityResource,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubResourceDebugResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Expression {
+    #[serde(rename = "type")]
+    pub type_: expression::Type,
+    pub value: String,
+}
+pub mod expression {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Expression,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecureString {
+    #[serde(flatten)]
+    pub secret_base: SecretBase,
+    pub value: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultSecretReference {
+    #[serde(flatten)]
+    pub secret_base: SecretBase,
+    pub store: LinkedServiceReference,
+    #[serde(rename = "secretName")]
+    pub secret_name: serde_json::Value,
+    #[serde(rename = "secretVersion", default, skip_serializing_if = "Option::is_none")]
+    pub secret_version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecretBase {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeReference {
+    #[serde(rename = "type")]
+    pub type_: integration_runtime_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod integration_runtime_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        IntegrationRuntimeReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudError {
+    pub error: CloudErrorBody,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudErrorBody {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<CloudError>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerDependencyProvisioningStatus {
+    #[serde(rename = "triggerName")]
+    pub trigger_name: String,
+    #[serde(rename = "provisioningStatus")]
+    pub provisioning_status: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VariableDefinitionSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VariableSpecification {
+    #[serde(rename = "type")]
+    pub type_: variable_specification::Type,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+pub mod variable_specification {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        String,
+        Bool,
+        Boolean,
+        Array,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterDefinitionSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterSpecification {
+    #[serde(rename = "type")]
+    pub type_: parameter_specification::Type,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+pub mod parameter_specification {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Object,
+        String,
+        Int,
+        Float,
+        Bool,
+        Array,
+        SecureString,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterValueSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineReference {
+    #[serde(rename = "type")]
+    pub type_: pipeline_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+pub mod pipeline_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        PipelineReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerPipelineReference {
+    #[serde(rename = "pipelineReference", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_reference: Option<PipelineReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceUpdateParameters {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<WorkspaceIdentity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceIdentity {
+    #[serde(rename = "type")]
+    pub type_: workspace_identity::Type,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
+pub mod workspace_identity {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SystemAssigned,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetReference {
+    #[serde(rename = "type")]
+    pub type_: dataset_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod dataset_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        DatasetReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceReference {
+    #[serde(rename = "type")]
+    pub type_: linked_service_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod linked_service_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        LinkedServiceReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowReference {
+    #[serde(rename = "type")]
+    pub type_: data_flow_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(rename = "datasetParameters", default, skip_serializing_if = "Option::is_none")]
+    pub dataset_parameters: Option<serde_json::Value>,
+}
+pub mod data_flow_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        DataFlowReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowStagingInfo {
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunFilterParameters {
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+    #[serde(rename = "lastUpdatedAfter")]
+    pub last_updated_after: String,
+    #[serde(rename = "lastUpdatedBefore")]
+    pub last_updated_before: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub filters: Vec<RunQueryFilter>,
+    #[serde(rename = "orderBy", default, skip_serializing_if = "Vec::is_empty")]
+    pub order_by: Vec<RunQueryOrderBy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunQueryFilter {
+    pub operand: run_query_filter::Operand,
+    pub operator: run_query_filter::Operator,
+    pub values: Vec<String>,
+}
+pub mod run_query_filter {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operand {
+        PipelineName,
+        Status,
+        RunStart,
+        RunEnd,
+        ActivityName,
+        ActivityRunStart,
+        ActivityRunEnd,
+        ActivityType,
+        TriggerName,
+        TriggerRunTimestamp,
+        RunGroupId,
+        LatestOnly,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operator {
+        Equals,
+        NotEquals,
+        In,
+        NotIn,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunQueryOrderBy {
+    #[serde(rename = "orderBy")]
+    pub order_by: run_query_order_by::OrderBy,
+    pub order: run_query_order_by::Order,
+}
+pub mod run_query_order_by {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OrderBy {
+        RunStart,
+        RunEnd,
+        PipelineName,
+        Status,
+        ActivityName,
+        ActivityRunStart,
+        ActivityRunEnd,
+        TriggerName,
+        TriggerRunTimestamp,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Order {
+        #[serde(rename = "ASC")]
+        Asc,
+        #[serde(rename = "DESC")]
+        Desc,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTumblingWindowTriggerActionParameters {
+    #[serde(rename = "startTime")]
+    pub start_time: String,
+    #[serde(rename = "endTime")]
+    pub end_time: String,
+    #[serde(rename = "maxConcurrency")]
+    pub max_concurrency: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTriggerListResponse {
+    pub value: Vec<RerunTriggerResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTriggerResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: RerunTumblingWindowTrigger,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetSsisObjectMetadataRequest {
+    #[serde(rename = "metadataPath", default, skip_serializing_if = "Option::is_none")]
+    pub metadata_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisObjectMetadataStatusResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExposureControlRequest {
+    #[serde(rename = "featureName", default, skip_serializing_if = "Option::is_none")]
+    pub feature_name: Option<String>,
+    #[serde(rename = "featureType", default, skip_serializing_if = "Option::is_none")]
+    pub feature_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExposureControlResponse {
+    #[serde(rename = "featureName", default, skip_serializing_if = "Option::is_none")]
+    pub feature_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookReference {
+    #[serde(rename = "type")]
+    pub type_: synapse_notebook_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod synapse_notebook_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        NotebookReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobReference {
+    #[serde(rename = "type")]
+    pub type_: synapse_spark_job_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod synapse_spark_job_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SparkJobDefinitionReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolReference {
+    #[serde(rename = "type")]
+    pub type_: sql_pool_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod sql_pool_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlPoolReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ArtifactRenameRequest {
+    #[serde(rename = "newName", default, skip_serializing_if = "Option::is_none")]
+    pub new_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Trigger {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "runtimeState", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_state: Option<TriggerRuntimeState>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TriggerRuntimeState {
+    Started,
+    Stopped,
+    Disabled,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MultiplePipelineTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub pipelines: Vec<TriggerPipelineReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScheduleTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: schedule_trigger::TypeProperties,
+}
+pub mod schedule_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        pub recurrence: ScheduleTriggerRecurrence,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScheduleTriggerRecurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub frequency: Option<RecurrenceFrequency>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub interval: Option<i32>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(rename = "timeZone", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule: Option<RecurrenceSchedule>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum RecurrenceFrequency {
+    NotSpecified,
+    Minute,
+    Hour,
+    Day,
+    Week,
+    Month,
+    Year,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceSchedule {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub minutes: Vec<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub hours: Vec<i32>,
+    #[serde(rename = "weekDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub week_days: Vec<String>,
+    #[serde(rename = "monthDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub month_days: Vec<i32>,
+    #[serde(rename = "monthlyOccurrences", default, skip_serializing_if = "Vec::is_empty")]
+    pub monthly_occurrences: Vec<RecurrenceScheduleOccurrence>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceScheduleOccurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub day: Option<DayOfWeek>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub occurrence: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DayOfWeek {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: blob_trigger::TypeProperties,
+}
+pub mod blob_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "folderPath")]
+        pub folder_path: String,
+        #[serde(rename = "maxConcurrency")]
+        pub max_concurrency: i64,
+        #[serde(rename = "linkedService")]
+        pub linked_service: LinkedServiceReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobEventsTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: blob_events_trigger::TypeProperties,
+}
+pub mod blob_events_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "blobPathBeginsWith", default, skip_serializing_if = "Option::is_none")]
+        pub blob_path_begins_with: Option<String>,
+        #[serde(rename = "blobPathEndsWith", default, skip_serializing_if = "Option::is_none")]
+        pub blob_path_ends_with: Option<String>,
+        #[serde(rename = "ignoreEmptyBlobs", default, skip_serializing_if = "Option::is_none")]
+        pub ignore_empty_blobs: Option<bool>,
+        pub events: BlobEventTypes,
+        pub scope: String,
+    }
+}
+pub type BlobEventTypes = Vec<String>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomEventsTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: custom_events_trigger::TypeProperties,
+}
+pub mod custom_events_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "subjectBeginsWith", default, skip_serializing_if = "Option::is_none")]
+        pub subject_begins_with: Option<String>,
+        #[serde(rename = "subjectEndsWith", default, skip_serializing_if = "Option::is_none")]
+        pub subject_ends_with: Option<String>,
+        pub events: Vec<serde_json::Value>,
+        pub scope: String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TumblingWindowTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    pub pipeline: TriggerPipelineReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: tumbling_window_trigger::TypeProperties,
+}
+pub mod tumbling_window_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        pub frequency: TumblingWindowFrequency,
+        pub interval: i32,
+        #[serde(rename = "startTime")]
+        pub start_time: String,
+        #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+        pub end_time: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub delay: Option<serde_json::Value>,
+        #[serde(rename = "maxConcurrency")]
+        pub max_concurrency: i64,
+        #[serde(rename = "retryPolicy", default, skip_serializing_if = "Option::is_none")]
+        pub retry_policy: Option<RetryPolicy>,
+        #[serde(rename = "dependsOn", default, skip_serializing_if = "Vec::is_empty")]
+        pub depends_on: Vec<DependencyReference>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TumblingWindowFrequency {
+    Minute,
+    Hour,
+    Month,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RetryPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<serde_json::Value>,
+    #[serde(rename = "intervalInSeconds", default, skip_serializing_if = "Option::is_none")]
+    pub interval_in_seconds: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerReference {
+    #[serde(rename = "type")]
+    pub type_: trigger_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod trigger_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        TriggerReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DependencyReference {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerDependencyReference {
+    #[serde(flatten)]
+    pub dependency_reference: DependencyReference,
+    #[serde(rename = "referenceTrigger")]
+    pub reference_trigger: TriggerReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TumblingWindowTriggerDependencyReference {
+    #[serde(flatten)]
+    pub trigger_dependency_reference: TriggerDependencyReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offset: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SelfDependencyTumblingWindowTriggerReference {
+    #[serde(flatten)]
+    pub dependency_reference: DependencyReference,
+    pub offset: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTumblingWindowTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: rerun_tumbling_window_trigger::TypeProperties,
+}
+pub mod rerun_tumbling_window_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "parentTrigger")]
+        pub parent_trigger: serde_json::Value,
+        #[serde(rename = "requestedStartTime")]
+        pub requested_start_time: String,
+        #[serde(rename = "requestedEndTime")]
+        pub requested_end_time: String,
+        #[serde(rename = "rerunConcurrency")]
+        pub rerun_concurrency: i64,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ChainingTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    pub pipeline: TriggerPipelineReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: chaining_trigger::TypeProperties,
+}
+pub mod chaining_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "dependsOn")]
+        pub depends_on: Vec<PipelineReference>,
+        #[serde(rename = "runDimension")]
+        pub run_dimension: String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowListResponse {
+    pub value: Vec<DataFlowResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: DataFlow,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateDataFlowDebugSessionRequest {
+    #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+    pub compute_type: Option<String>,
+    #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+    pub core_count: Option<i64>,
+    #[serde(rename = "timeToLive", default, skip_serializing_if = "Option::is_none")]
+    pub time_to_live: Option<i64>,
+    #[serde(rename = "integrationRuntime", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime: Option<IntegrationRuntimeDebugResource>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: IntegrationRuntime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateDataFlowDebugSessionResponse {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryDataFlowDebugSessionsResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<DataFlowDebugSessionInfo>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugSessionInfo {
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+    pub compute_type: Option<String>,
+    #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+    pub core_count: Option<i64>,
+    #[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub node_count: Option<i64>,
+    #[serde(rename = "integrationRuntimeName", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime_name: Option<String>,
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "timeToLiveInMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub time_to_live_in_minutes: Option<i64>,
+    #[serde(rename = "lastActivityTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_activity_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugPackage {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlow", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow: Option<DataFlowDebugResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetDebugResource>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceDebugResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<DataFlowStagingInfo>,
+    #[serde(rename = "debugSettings", default, skip_serializing_if = "Option::is_none")]
+    pub debug_settings: Option<data_flow_debug_package::DebugSettings>,
+}
+pub mod data_flow_debug_package {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct DebugSettings {
+        #[serde(rename = "sourceSettings", default, skip_serializing_if = "Vec::is_empty")]
+        pub source_settings: Vec<DataFlowSourceSetting>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub parameters: Option<ParameterValueSpecification>,
+        #[serde(rename = "datasetParameters", default, skip_serializing_if = "Option::is_none")]
+        pub dataset_parameters: Option<serde_json::Value>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSourceSetting {
+    #[serde(rename = "sourceName", default, skip_serializing_if = "Option::is_none")]
+    pub source_name: Option<String>,
+    #[serde(rename = "rowLimit", default, skip_serializing_if = "Option::is_none")]
+    pub row_limit: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: DataFlow,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AddDataFlowToDebugSessionResponse {
+    #[serde(rename = "jobVersion", default, skip_serializing_if = "Option::is_none")]
+    pub job_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StartDataFlowDebugSessionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlow", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow: Option<DataFlowResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetResource>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<serde_json::Value>,
+    #[serde(rename = "debugSettings", default, skip_serializing_if = "Option::is_none")]
+    pub debug_settings: Option<serde_json::Value>,
+    #[serde(rename = "incrementalDebug", default, skip_serializing_if = "Option::is_none")]
+    pub incremental_debug: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StartDataFlowDebugSessionResponse {
+    #[serde(rename = "jobVersion", default, skip_serializing_if = "Option::is_none")]
+    pub job_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteDataFlowDebugSessionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugPreviewDataRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugStatisticsRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EvaluateDataFlowExpressionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expression: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub command: Option<data_flow_debug_command_request::Command>,
+    #[serde(rename = "commandPayload", default, skip_serializing_if = "Option::is_none")]
+    pub command_payload: Option<DataFlowDebugCommandPayload>,
+}
+pub mod data_flow_debug_command_request {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Command {
+        #[serde(rename = "executePreviewQuery")]
+        ExecutePreviewQuery,
+        #[serde(rename = "executeStatisticsQuery")]
+        ExecuteStatisticsQuery,
+        #[serde(rename = "executeExpressionQuery")]
+        ExecuteExpressionQuery,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandPayload {
+    #[serde(rename = "streamName")]
+    pub stream_name: String,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expression: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugQueryResponse {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugResultResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: LinkedService,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlow {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<data_flow::Folder>,
+}
+pub mod data_flow {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MappingDataFlow {
+    #[serde(flatten)]
+    pub data_flow: DataFlow,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MappingDataFlowTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MappingDataFlowTypeProperties {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sources: Vec<DataFlowSource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sinks: Vec<DataFlowSink>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub transformations: Vec<Transformation>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub script: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Transformation {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSource {
+    #[serde(flatten)]
+    pub transformation: Transformation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<DatasetReference>,
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "schemaLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub schema_linked_service: Option<LinkedServiceReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSink {
+    #[serde(flatten)]
+    pub transformation: Transformation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<DatasetReference>,
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "schemaLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub schema_linked_service: Option<LinkedServiceReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetListResponse {
+    pub value: Vec<DatasetResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Dataset {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub structure: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<dataset::Folder>,
+}
+pub mod dataset {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetLocation {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub container: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "fileSystem", default, skip_serializing_if = "Option::is_none")]
+    pub file_system: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Location {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "bucketName", default, skip_serializing_if = "Option::is_none")]
+    pub bucket_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "bucketName", default, skip_serializing_if = "Option::is_none")]
+    pub bucket_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDataElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetSchemaDataElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetStorageFormat {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub serializer: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub deserializer: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TextFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+    #[serde(rename = "columnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "rowDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub row_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "escapeChar", default, skip_serializing_if = "Option::is_none")]
+    pub escape_char: Option<serde_json::Value>,
+    #[serde(rename = "quoteChar", default, skip_serializing_if = "Option::is_none")]
+    pub quote_char: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_line_count: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+    #[serde(rename = "filePattern", default, skip_serializing_if = "Option::is_none")]
+    pub file_pattern: Option<serde_json::Value>,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "jsonNodeReference", default, skip_serializing_if = "Option::is_none")]
+    pub json_node_reference: Option<serde_json::Value>,
+    #[serde(rename = "jsonPathDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub json_path_definition: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JsonFormatFilePattern {
+    #[serde(rename = "setOfObjects")]
+    SetOfObjects,
+    #[serde(rename = "arrayOfObjects")]
+    ArrayOfObjects,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetCompression {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetBZip2Compression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetGZipCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDeflateCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetZipDeflateCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetTarCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetTarGZipCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompressionLevel {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DatasetCompressionLevelEnum {
+    Optimal,
+    Fastest,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Dataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonS3DatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3DatasetTypeProperties {
+    #[serde(rename = "bucketName")]
+    pub bucket_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AvroDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "avroCompressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub avro_compression_codec: Option<serde_json::Value>,
+    #[serde(rename = "avroCompressionLevel", default, skip_serializing_if = "Option::is_none")]
+    pub avro_compression_level: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AvroCompressionCodecEnum {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "deflate")]
+    Deflate,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "xz")]
+    Xz,
+    #[serde(rename = "bzip2")]
+    Bzip2,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ExcelDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "sheetName")]
+    pub sheet_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub range: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ParquetDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "compressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub compression_codec: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ParquetCompressionCodecEnum {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "gzip")]
+    Gzip,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lzo")]
+    Lzo,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DelimitedTextDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "columnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "rowDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub row_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "compressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub compression_codec: Option<serde_json::Value>,
+    #[serde(rename = "compressionLevel", default, skip_serializing_if = "Option::is_none")]
+    pub compression_level: Option<serde_json::Value>,
+    #[serde(rename = "quoteChar", default, skip_serializing_if = "Option::is_none")]
+    pub quote_char: Option<serde_json::Value>,
+    #[serde(rename = "escapeChar", default, skip_serializing_if = "Option::is_none")]
+    pub escape_char: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum CompressionCodec {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "lzo")]
+    Lzo,
+    #[serde(rename = "bzip2")]
+    Bzip2,
+    #[serde(rename = "gzip")]
+    Gzip,
+    #[serde(rename = "deflate")]
+    Deflate,
+    #[serde(rename = "zipDeflate")]
+    ZipDeflate,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lz4")]
+    Lz4,
+    #[serde(rename = "tar")]
+    Tar,
+    #[serde(rename = "tarGZip")]
+    TarGZip,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<JsonDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<XmlDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OrcDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "orcCompressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub orc_compression_codec: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum OrcCompressionCodec {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "zlib")]
+    Zlib,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lzo")]
+    Lzo,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<BinaryDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureBlobDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "tableRootLocation", default, skip_serializing_if = "Option::is_none")]
+    pub table_root_location: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableDatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlMiTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlDwTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<CassandraTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub keyspace: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbSqlApiCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DocumentDbCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DynamicsEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DynamicsCrmEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<CommonDataServiceForAppsEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureDataLakeStoreDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureBlobFsDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365Dataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Office365DatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365DatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub predicate: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileShareDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<FileShareDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileShareDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(rename = "fileFilter", default, skip_serializing_if = "Option::is_none")]
+    pub file_filter: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbAtlasCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasCollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2CollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbV2CollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2CollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbMongoDbApiCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiCollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ODataResourceDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataResourceDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OracleTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRdsForOracleTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<TeradataTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMySqlTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRedshiftTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2TableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<Db2TableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2TableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<RelationalTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<InformixTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OdbcTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MySqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PostgreSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MicrosoftAccessTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SalesforceObjectDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceObjectDatasetTypeProperties {
+    #[serde(rename = "objectApiName", default, skip_serializing_if = "Option::is_none")]
+    pub object_api_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SalesforceServiceCloudObjectDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudObjectDatasetTypeProperties {
+    #[serde(rename = "objectApiName", default, skip_serializing_if = "Option::is_none")]
+    pub object_api_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SybaseTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwCubeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapCloudForCustomerResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapEccResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SapHanaTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapOpenHubTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubTableDatasetTypeProperties {
+    #[serde(rename = "openHubDestinationName")]
+    pub open_hub_destination_name: serde_json::Value,
+    #[serde(rename = "excludeLastRequest", default, skip_serializing_if = "Option::is_none")]
+    pub exclude_last_request: Option<serde_json::Value>,
+    #[serde(rename = "baseRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub base_request_id: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SqlServerTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRdsForSqlServerTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<RestResourceDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestResourceDatasetTypeProperties {
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "paginationRules", default, skip_serializing_if = "Option::is_none")]
+    pub pagination_rules: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapTableResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableResourceDatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebTableDatasetTypeProperties {
+    pub index: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSearchIndexDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexDatasetTypeProperties {
+    #[serde(rename = "indexName")]
+    pub index_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<HttpDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpDatasetTypeProperties {
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzurePostgreSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DrillDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GoogleBigQueryDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GreenplumDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<HiveDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ImpalaDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PhoenixDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PrestoDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SparkDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<NetezzaTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<VerticaDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsAxResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SnowflakeDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SharePointOnlineListDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListDatasetTypeProperties {
+    #[serde(rename = "listName", default, skip_serializing_if = "Option::is_none")]
+    pub list_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureDatabricksDeltaLakeDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceListResponse {
+    pub value: Vec<LinkedServiceResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: LinkedService,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedService {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "connectVia", default, skip_serializing_if = "Option::is_none")]
+    pub connect_via: Option<IntegrationRuntimeReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBlobStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "serviceEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub service_endpoint: Option<String>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "accountKind", default, skip_serializing_if = "Option::is_none")]
+    pub account_kind: Option<String>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlDwLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRdsForSqlServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlDatabaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlMiLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBatchLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBatchLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBatchLinkedServiceTypeProperties {
+    #[serde(rename = "accountName")]
+    pub account_name: serde_json::Value,
+    #[serde(rename = "accessKey", default, skip_serializing_if = "Option::is_none")]
+    pub access_key: Option<SecretBase>,
+    #[serde(rename = "batchUri")]
+    pub batch_uri: serde_json::Value,
+    #[serde(rename = "poolName")]
+    pub pool_name: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureKeyVaultLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultLinkedServiceTypeProperties {
+    #[serde(rename = "baseUrl")]
+    pub base_url: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub account_endpoint: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsDeploymentType {
+    Online,
+    OnPremisesWithIfd,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsAuthenticationType {
+    Office365,
+    Ifd,
+    #[serde(rename = "AADServicePrincipal")]
+    AadServicePrincipal,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsCrmLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ServicePrincipalCredentialEnum {
+    ServicePrincipalKey,
+    ServicePrincipalCert,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CommonDataServiceForAppsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightLinkedServiceTypeProperties {
+    #[serde(rename = "clusterUri")]
+    pub cluster_uri: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "hcatalogLinkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub hcatalog_linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "isEspEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_esp_enabled: Option<serde_json::Value>,
+    #[serde(rename = "fileSystem", default, skip_serializing_if = "Option::is_none")]
+    pub file_system: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FileServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFileStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "fileShare", default, skip_serializing_if = "Option::is_none")]
+    pub file_share: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub snapshot: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleCloudStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLinkedServiceTypeProperties {
+    #[serde(rename = "accessKeyId", default, skip_serializing_if = "Option::is_none")]
+    pub access_key_id: Option<serde_json::Value>,
+    #[serde(rename = "secretAccessKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_access_key: Option<SecretBase>,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OracleLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRdsForLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMySqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MySqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PostgreSqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SybaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sybase_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod sybase_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Db2LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2LinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    pub server: serde_json::Value,
+    pub database: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<db2_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "packageCollection", default, skip_serializing_if = "Option::is_none")]
+    pub package_collection: Option<serde_json::Value>,
+    #[serde(rename = "certificateCommonName", default, skip_serializing_if = "Option::is_none")]
+    pub certificate_common_name: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod db2_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: TeradataLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<teradata_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod teradata_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlLinkedServiceTypeProperties {
+    #[serde(rename = "mlEndpoint")]
+    pub ml_endpoint: serde_json::Value,
+    #[serde(rename = "apiKey")]
+    pub api_key: SecretBase,
+    #[serde(rename = "updateResourceEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub update_resource_endpoint: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlServiceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlServiceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlServiceLinkedServiceTypeProperties {
+    #[serde(rename = "subscriptionId")]
+    pub subscription_id: serde_json::Value,
+    #[serde(rename = "resourceGroupName")]
+    pub resource_group_name: serde_json::Value,
+    #[serde(rename = "mlWorkspaceName")]
+    pub ml_workspace_name: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OdbcLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: InformixLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MicrosoftAccessLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdfsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ODataLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<o_data_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "aadResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub aad_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "aadServicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub aad_service_principal_credential_type: Option<o_data_linked_service_type_properties::AadServicePrincipalCredentialType>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalEmbeddedCert", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_embedded_cert: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalEmbeddedCertPassword", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_embedded_cert_password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod o_data_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        Windows,
+        AadServicePrincipal,
+        ManagedServiceIdentity,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AadServicePrincipalCredentialType {
+        ServicePrincipalKey,
+        ServicePrincipalCert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: web_linked_service_type_properties::AuthenticationType,
+}
+pub mod web_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        ClientCertificate,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebAnonymousAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebBasicAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+    pub username: serde_json::Value,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebClientCertificateAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+    pub pfx: SecretBase,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CassandraLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<mongo_db_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "databaseName")]
+    pub database_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "authSource", default, skip_serializing_if = "Option::is_none")]
+    pub auth_source: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod mongo_db_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbAtlasLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbV2LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2LinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbMongoDbApiLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataLakeStoreLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLinkedServiceTypeProperties {
+    #[serde(rename = "dataLakeStoreUri")]
+    pub data_lake_store_uri: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<serde_json::Value>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<serde_json::Value>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBlobFsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Office365LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365LinkedServiceTypeProperties {
+    #[serde(rename = "office365TenantId")]
+    pub office365_tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalTenantId")]
+    pub service_principal_tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceLinkedServiceTypeProperties {
+    #[serde(rename = "environmentUrl", default, skip_serializing_if = "Option::is_none")]
+    pub environment_url: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "securityToken", default, skip_serializing_if = "Option::is_none")]
+    pub security_token: Option<SecretBase>,
+    #[serde(rename = "apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceServiceCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudLinkedServiceTypeProperties {
+    #[serde(rename = "environmentUrl", default, skip_serializing_if = "Option::is_none")]
+    pub environment_url: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "securityToken", default, skip_serializing_if = "Option::is_none")]
+    pub security_token: Option<SecretBase>,
+    #[serde(rename = "apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<serde_json::Value>,
+    #[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapCloudForCustomerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapEccLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccLinkedServiceTypeProperties {
+    pub url: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapOpenHubLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "systemNumber")]
+    pub system_number: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<serde_json::Value>,
+    #[serde(rename = "systemId", default, skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "messageServer", default, skip_serializing_if = "Option::is_none")]
+    pub message_server: Option<serde_json::Value>,
+    #[serde(rename = "messageServerService", default, skip_serializing_if = "Option::is_none")]
+    pub message_server_service: Option<serde_json::Value>,
+    #[serde(rename = "logonGroup", default, skip_serializing_if = "Option::is_none")]
+    pub logon_group: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestServiceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: RestServiceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestServiceLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: rest_service_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "aadResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub aad_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod rest_service_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Basic,
+        AadServicePrincipal,
+        ManagedServiceIdentity,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonS3LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3LinkedServiceTypeProperties {
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(rename = "accessKeyId", default, skip_serializing_if = "Option::is_none")]
+    pub access_key_id: Option<serde_json::Value>,
+    #[serde(rename = "secretAccessKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_access_key: Option<SecretBase>,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<serde_json::Value>,
+    #[serde(rename = "sessionToken", default, skip_serializing_if = "Option::is_none")]
+    pub session_token: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRedshiftLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomDataSourceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSearchLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HttpLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<http_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "embeddedCertData", default, skip_serializing_if = "Option::is_none")]
+    pub embedded_cert_data: Option<serde_json::Value>,
+    #[serde(rename = "certThumbprint", default, skip_serializing_if = "Option::is_none")]
+    pub cert_thumbprint: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+}
+pub mod http_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        Digest,
+        Windows,
+        ClientCertificate,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FtpServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<ftp_server_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+}
+pub mod ftp_server_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SftpServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sftp_server_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "privateKeyPath", default, skip_serializing_if = "Option::is_none")]
+    pub private_key_path: Option<serde_json::Value>,
+    #[serde(rename = "privateKeyContent", default, skip_serializing_if = "Option::is_none")]
+    pub private_key_content: Option<SecretBase>,
+    #[serde(rename = "passPhrase", default, skip_serializing_if = "Option::is_none")]
+    pub pass_phrase: Option<SecretBase>,
+    #[serde(rename = "skipHostKeyValidation", default, skip_serializing_if = "Option::is_none")]
+    pub skip_host_key_validation: Option<serde_json::Value>,
+    #[serde(rename = "hostKeyFingerprint", default, skip_serializing_if = "Option::is_none")]
+    pub host_key_fingerprint: Option<serde_json::Value>,
+}
+pub mod sftp_server_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        SshPublicKey,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapBwLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "systemNumber")]
+    pub system_number: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapHanaLinkedServiceProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaLinkedServiceProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    pub server: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sap_hana_linked_service_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod sap_hana_linked_service_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonMwsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "marketplaceID")]
+    pub marketplace_id: serde_json::Value,
+    #[serde(rename = "sellerID")]
+    pub seller_id: serde_json::Value,
+    #[serde(rename = "mwsAuthToken", default, skip_serializing_if = "Option::is_none")]
+    pub mws_auth_token: Option<SecretBase>,
+    #[serde(rename = "accessKeyId")]
+    pub access_key_id: serde_json::Value,
+    #[serde(rename = "secretKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_key: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzurePostgreSqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ConcurLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CouchbaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "credString", default, skip_serializing_if = "Option::is_none")]
+    pub cred_string: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DrillLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: EloquaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleBigQueryLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryLinkedServiceTypeProperties {
+    pub project: serde_json::Value,
+    #[serde(rename = "additionalProjects", default, skip_serializing_if = "Option::is_none")]
+    pub additional_projects: Option<serde_json::Value>,
+    #[serde(rename = "requestGoogleDriveScope", default, skip_serializing_if = "Option::is_none")]
+    pub request_google_drive_scope: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: google_big_query_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub email: Option<serde_json::Value>,
+    #[serde(rename = "keyFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub key_file_path: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod google_big_query_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        ServiceAuthentication,
+        UserAuthentication,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GreenplumLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HBaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: h_base_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod h_base_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Basic,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HiveLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serverType", default, skip_serializing_if = "Option::is_none")]
+    pub server_type: Option<hive_linked_service_type_properties::ServerType>,
+    #[serde(rename = "thriftTransportProtocol", default, skip_serializing_if = "Option::is_none")]
+    pub thrift_transport_protocol: Option<hive_linked_service_type_properties::ThriftTransportProtocol>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: hive_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "serviceDiscoveryMode", default, skip_serializing_if = "Option::is_none")]
+    pub service_discovery_mode: Option<serde_json::Value>,
+    #[serde(rename = "zooKeeperNameSpace", default, skip_serializing_if = "Option::is_none")]
+    pub zoo_keeper_name_space: Option<serde_json::Value>,
+    #[serde(rename = "useNativeQuery", default, skip_serializing_if = "Option::is_none")]
+    pub use_native_query: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod hive_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServerType {
+        HiveServer1,
+        HiveServer2,
+        HiveThriftServer,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ThriftTransportProtocol {
+        Binary,
+        #[serde(rename = "SASL")]
+        Sasl,
+        #[serde(rename = "HTTP ")]
+        Http,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Username,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HubspotLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotLinkedServiceTypeProperties {
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ImpalaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: impala_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod impala_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        #[serde(rename = "SASLUsername")]
+        SaslUsername,
+        UsernameAndPassword,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: JiraLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MagentoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MariaDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMariaDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MarketoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PaypalLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PhoenixLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: phoenix_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod phoenix_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PrestoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "serverVersion")]
+    pub server_version: serde_json::Value,
+    pub catalog: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: presto_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "timeZoneID", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod presto_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        #[serde(rename = "LDAP")]
+        Ldap,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: QuickBooksLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "companyId")]
+    pub company_id: serde_json::Value,
+    #[serde(rename = "consumerKey")]
+    pub consumer_key: serde_json::Value,
+    #[serde(rename = "consumerSecret")]
+    pub consumer_secret: SecretBase,
+    #[serde(rename = "accessToken")]
+    pub access_token: SecretBase,
+    #[serde(rename = "accessTokenSecret")]
+    pub access_token_secret: SecretBase,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ServiceNowLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: service_now_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod service_now_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        OAuth2,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ShopifyLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SparkLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    pub port: serde_json::Value,
+    #[serde(rename = "serverType", default, skip_serializing_if = "Option::is_none")]
+    pub server_type: Option<spark_linked_service_type_properties::ServerType>,
+    #[serde(rename = "thriftTransportProtocol", default, skip_serializing_if = "Option::is_none")]
+    pub thrift_transport_protocol: Option<spark_linked_service_type_properties::ThriftTransportProtocol>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: spark_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod spark_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServerType {
+        SharkServer,
+        SharkServer2,
+        SparkThriftServer,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ThriftTransportProtocol {
+        Binary,
+        #[serde(rename = "SASL")]
+        Sasl,
+        #[serde(rename = "HTTP ")]
+        Http,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Username,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SquareLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub host: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "redirectUri")]
+    pub redirect_uri: serde_json::Value,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: XeroLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub host: serde_json::Value,
+    #[serde(rename = "consumerKey", default, skip_serializing_if = "Option::is_none")]
+    pub consumer_key: Option<SecretBase>,
+    #[serde(rename = "privateKey", default, skip_serializing_if = "Option::is_none")]
+    pub private_key: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ZohoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: VerticaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: NetezzaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceMarketingCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightOnDemandLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightOnDemandLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightOnDemandLinkedServiceTypeProperties {
+    #[serde(rename = "clusterSize")]
+    pub cluster_size: serde_json::Value,
+    #[serde(rename = "timeToLive")]
+    pub time_to_live: serde_json::Value,
+    pub version: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(rename = "hostSubscriptionId")]
+    pub host_subscription_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "clusterResourceGroup")]
+    pub cluster_resource_group: serde_json::Value,
+    #[serde(rename = "clusterNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_name_prefix: Option<serde_json::Value>,
+    #[serde(rename = "clusterUserName", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_user_name: Option<serde_json::Value>,
+    #[serde(rename = "clusterPassword", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_password: Option<SecretBase>,
+    #[serde(rename = "clusterSshUserName", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_ssh_user_name: Option<serde_json::Value>,
+    #[serde(rename = "clusterSshPassword", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_ssh_password: Option<SecretBase>,
+    #[serde(rename = "additionalLinkedServiceNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_linked_service_names: Vec<LinkedServiceReference>,
+    #[serde(rename = "hcatalogLinkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub hcatalog_linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "clusterType", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_type: Option<serde_json::Value>,
+    #[serde(rename = "sparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub spark_version: Option<serde_json::Value>,
+    #[serde(rename = "coreConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub core_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hBaseConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub h_base_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hdfsConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub hdfs_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hiveConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub hive_configuration: Option<serde_json::Value>,
+    #[serde(rename = "mapReduceConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub map_reduce_configuration: Option<serde_json::Value>,
+    #[serde(rename = "oozieConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub oozie_configuration: Option<serde_json::Value>,
+    #[serde(rename = "stormConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub storm_configuration: Option<serde_json::Value>,
+    #[serde(rename = "yarnConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_configuration: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "headNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub head_node_size: Option<serde_json::Value>,
+    #[serde(rename = "dataNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub data_node_size: Option<serde_json::Value>,
+    #[serde(rename = "zookeeperNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub zookeeper_node_size: Option<serde_json::Value>,
+    #[serde(rename = "scriptActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub script_actions: Vec<ScriptAction>,
+    #[serde(rename = "virtualNetworkId", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_network_id: Option<serde_json::Value>,
+    #[serde(rename = "subnetName", default, skip_serializing_if = "Option::is_none")]
+    pub subnet_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScriptAction {
+    pub name: String,
+    pub uri: String,
+    pub roles: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum HdiNodeTypes {
+    Headnode,
+    Workernode,
+    Zookeeper,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeAnalyticsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataLakeAnalyticsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeAnalyticsLinkedServiceTypeProperties {
+    #[serde(rename = "accountName")]
+    pub account_name: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<serde_json::Value>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<serde_json::Value>,
+    #[serde(rename = "dataLakeAnalyticsUri", default, skip_serializing_if = "Option::is_none")]
+    pub data_lake_analytics_uri: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDatabricksLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksLinkedServiceTypeProperties {
+    pub domain: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<serde_json::Value>,
+    #[serde(rename = "workspaceResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "existingClusterId", default, skip_serializing_if = "Option::is_none")]
+    pub existing_cluster_id: Option<serde_json::Value>,
+    #[serde(rename = "instancePoolId", default, skip_serializing_if = "Option::is_none")]
+    pub instance_pool_id: Option<serde_json::Value>,
+    #[serde(rename = "newClusterVersion", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_version: Option<serde_json::Value>,
+    #[serde(rename = "newClusterNumOfWorker", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_num_of_worker: Option<serde_json::Value>,
+    #[serde(rename = "newClusterNodeType", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_node_type: Option<serde_json::Value>,
+    #[serde(rename = "newClusterSparkConf", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_spark_conf: Option<serde_json::Value>,
+    #[serde(rename = "newClusterSparkEnvVars", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_spark_env_vars: Option<serde_json::Value>,
+    #[serde(rename = "newClusterCustomTags", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_custom_tags: Option<serde_json::Value>,
+    #[serde(rename = "newClusterLogDestination", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_log_destination: Option<serde_json::Value>,
+    #[serde(rename = "newClusterDriverNodeType", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_driver_node_type: Option<serde_json::Value>,
+    #[serde(rename = "newClusterInitScripts", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_init_scripts: Option<serde_json::Value>,
+    #[serde(rename = "newClusterEnableElasticDisk", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_enable_elastic_disk: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "policyId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_id: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDatabricksDetltaLakeLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDetltaLakeLinkedServiceTypeProperties {
+    pub domain: serde_json::Value,
+    #[serde(rename = "accessToken")]
+    pub access_token: SecretBase,
+    #[serde(rename = "clusterId", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ResponsysLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsAxLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "aadResourceId")]
+    pub aad_resource_id: serde_json::Value,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OracleServiceCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    pub username: serde_json::Value,
+    pub password: SecretBase,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleAdWordsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsLinkedServiceTypeProperties {
+    #[serde(rename = "clientCustomerID")]
+    pub client_customer_id: serde_json::Value,
+    #[serde(rename = "developerToken")]
+    pub developer_token: SecretBase,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: google_ad_words_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub email: Option<serde_json::Value>,
+    #[serde(rename = "keyFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub key_file_path: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod google_ad_words_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        ServiceAuthentication,
+        UserAuthentication,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapTableLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableLinkedServiceTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<serde_json::Value>,
+    #[serde(rename = "systemNumber", default, skip_serializing_if = "Option::is_none")]
+    pub system_number: Option<serde_json::Value>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<serde_json::Value>,
+    #[serde(rename = "systemId", default, skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "messageServer", default, skip_serializing_if = "Option::is_none")]
+    pub message_server: Option<serde_json::Value>,
+    #[serde(rename = "messageServerService", default, skip_serializing_if = "Option::is_none")]
+    pub message_server_service: Option<serde_json::Value>,
+    #[serde(rename = "sncMode", default, skip_serializing_if = "Option::is_none")]
+    pub snc_mode: Option<serde_json::Value>,
+    #[serde(rename = "sncMyName", default, skip_serializing_if = "Option::is_none")]
+    pub snc_my_name: Option<serde_json::Value>,
+    #[serde(rename = "sncPartnerName", default, skip_serializing_if = "Option::is_none")]
+    pub snc_partner_name: Option<serde_json::Value>,
+    #[serde(rename = "sncLibraryPath", default, skip_serializing_if = "Option::is_none")]
+    pub snc_library_path: Option<serde_json::Value>,
+    #[serde(rename = "sncQop", default, skip_serializing_if = "Option::is_none")]
+    pub snc_qop: Option<serde_json::Value>,
+    #[serde(rename = "logonGroup", default, skip_serializing_if = "Option::is_none")]
+    pub logon_group: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFunctionLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionLinkedServiceTypeProperties {
+    #[serde(rename = "functionAppUrl")]
+    pub function_app_url: serde_json::Value,
+    #[serde(rename = "functionKey", default, skip_serializing_if = "Option::is_none")]
+    pub function_key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SnowflakeLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SharePointOnlineListLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListLinkedServiceTypeProperties {
+    #[serde(rename = "siteUrl")]
+    pub site_url: serde_json::Value,
+    #[serde(rename = "tenantId")]
+    pub tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubAccessTokenRequest {
+    #[serde(rename = "gitHubClientId")]
+    pub git_hub_client_id: String,
+    #[serde(rename = "gitHubAccessCode")]
+    pub git_hub_access_code: String,
+    #[serde(rename = "gitHubAccessTokenBaseUrl")]
+    pub git_hub_access_token_base_url: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubAccessTokenResponse {
+    #[serde(rename = "gitHubAccessToken", default, skip_serializing_if = "Option::is_none")]
+    pub git_hub_access_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OperationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<CloudErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryListResponse {
+    pub value: Vec<LibraryResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResourceInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "recordId", default, skip_serializing_if = "Option::is_none")]
+    pub record_id: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub created: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub changed: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "operationId", default, skip_serializing_if = "Option::is_none")]
+    pub operation_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: LibraryResourceProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResourceProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "containerName", default, skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+    #[serde(rename = "uploadedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub uploaded_timestamp: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<String>,
+    #[serde(rename = "creatorId", default, skip_serializing_if = "Option::is_none")]
+    pub creator_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookListResponse {
+    pub value: Vec<NotebookResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    pub properties: Notebook,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Notebook {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "bigDataPool", default, skip_serializing_if = "Option::is_none")]
+    pub big_data_pool: Option<BigDataPoolReference>,
+    #[serde(rename = "sessionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub session_properties: Option<NotebookSessionProperties>,
+    pub metadata: NotebookMetadata,
+    pub nbformat: i64,
+    pub nbformat_minor: i64,
+    pub cells: Vec<NotebookCell>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<notebook::Folder>,
+}
+pub mod notebook {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolReference {
+    #[serde(rename = "type")]
+    pub type_: big_data_pool_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod big_data_pool_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        BigDataPoolReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookMetadata {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kernelspec: Option<NotebookKernelSpec>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language_info: Option<NotebookLanguageInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookKernelSpec {
+    pub name: String,
+    pub display_name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookLanguageInfo {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub codemirror_mode: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookCell {
+    pub cell_type: String,
+    pub metadata: serde_json::Value,
+    pub source: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub attachments: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<NotebookCellOutputItem>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookSessionProperties {
+    #[serde(rename = "driverMemory")]
+    pub driver_memory: String,
+    #[serde(rename = "driverCores")]
+    pub driver_cores: i64,
+    #[serde(rename = "executorMemory")]
+    pub executor_memory: String,
+    #[serde(rename = "executorCores")]
+    pub executor_cores: i64,
+    #[serde(rename = "numExecutors")]
+    pub num_executors: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookCellOutputItem {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub execution_count: Option<i64>,
+    pub output_type: notebook_cell_output_item::OutputType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub text: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+}
+pub mod notebook_cell_output_item {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OutputType {
+        #[serde(rename = "execute_result")]
+        ExecuteResult,
+        #[serde(rename = "display_data")]
+        DisplayData,
+        #[serde(rename = "stream")]
+        Stream,
+        #[serde(rename = "error")]
+        Error,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineListResponse {
+    pub value: Vec<PipelineResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Pipeline,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateRunResponse {
+    #[serde(rename = "runId")]
+    pub run_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRunsQueryResponse {
+    pub value: Vec<PipelineRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRun {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "runGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub run_group_id: Option<String>,
+    #[serde(rename = "isLatest", default, skip_serializing_if = "Option::is_none")]
+    pub is_latest: Option<bool>,
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<serde_json::Value>,
+    #[serde(rename = "invokedBy", default, skip_serializing_if = "Option::is_none")]
+    pub invoked_by: Option<PipelineRunInvokedBy>,
+    #[serde(rename = "lastUpdated", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated: Option<String>,
+    #[serde(rename = "runStart", default, skip_serializing_if = "Option::is_none")]
+    pub run_start: Option<String>,
+    #[serde(rename = "runEnd", default, skip_serializing_if = "Option::is_none")]
+    pub run_end: Option<String>,
+    #[serde(rename = "durationInMs", default, skip_serializing_if = "Option::is_none")]
+    pub duration_in_ms: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRunInvokedBy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "invokedByType", default, skip_serializing_if = "Option::is_none")]
+    pub invoked_by_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityRunsQueryResponse {
+    pub value: Vec<ActivityRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityRun {
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(rename = "pipelineRunId", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_run_id: Option<String>,
+    #[serde(rename = "activityName", default, skip_serializing_if = "Option::is_none")]
+    pub activity_name: Option<String>,
+    #[serde(rename = "activityType", default, skip_serializing_if = "Option::is_none")]
+    pub activity_type: Option<String>,
+    #[serde(rename = "activityRunId", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_id: Option<String>,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "activityRunStart", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_start: Option<String>,
+    #[serde(rename = "activityRunEnd", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_end: Option<String>,
+    #[serde(rename = "durationInMs", default, skip_serializing_if = "Option::is_none")]
+    pub duration_in_ms: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub input: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Pipeline {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub activities: Vec<Activity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub variables: Option<VariableDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub concurrency: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(rename = "runDimensions", default, skip_serializing_if = "Option::is_none")]
+    pub run_dimensions: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<pipeline::Folder>,
+}
+pub mod pipeline {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Activity {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "dependsOn", default, skip_serializing_if = "Vec::is_empty")]
+    pub depends_on: Vec<ActivityDependency>,
+    #[serde(rename = "userProperties", default, skip_serializing_if = "Vec::is_empty")]
+    pub user_properties: Vec<UserProperty>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserProperty {
+    pub name: String,
+    pub value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityDependency {
+    pub activity: String,
+    #[serde(rename = "dependencyConditions")]
+    pub dependency_conditions: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ControlActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutionActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub policy: Option<ActivityPolicy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub retry: Option<serde_json::Value>,
+    #[serde(rename = "retryIntervalInSeconds", default, skip_serializing_if = "Option::is_none")]
+    pub retry_interval_in_seconds: Option<i64>,
+    #[serde(rename = "secureInput", default, skip_serializing_if = "Option::is_none")]
+    pub secure_input: Option<bool>,
+    #[serde(rename = "secureOutput", default, skip_serializing_if = "Option::is_none")]
+    pub secure_output: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoreReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "listAfter", default, skip_serializing_if = "Option::is_none")]
+    pub list_after: Option<serde_json::Value>,
+    #[serde(rename = "listBefore", default, skip_serializing_if = "Option::is_none")]
+    pub list_before: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3ReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(rename = "fileFilter", default, skip_serializing_if = "Option::is_none")]
+    pub file_filter: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "operationTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub operation_timeout: Option<serde_json::Value>,
+    #[serde(rename = "useTempFileRename", default, skip_serializing_if = "Option::is_none")]
+    pub use_temp_file_rename: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "useBinaryTransfer", default, skip_serializing_if = "Option::is_none")]
+    pub use_binary_transfer: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "requestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(rename = "distcpSettings", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_settings: Option<DistcpSettings>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoreWriteSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "blockSizeInMB", default, skip_serializing_if = "Option::is_none")]
+    pub block_size_in_mb: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "blockSizeInMB", default, skip_serializing_if = "Option::is_none")]
+    pub block_size_in_mb: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "expiryDateTime", default, skip_serializing_if = "Option::is_none")]
+    pub expiry_date_time: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FormatReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompressionReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZipDeflateReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveZipFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_zip_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TarReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveCompressionFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_compression_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TarGZipReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveCompressionFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_compression_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "skipLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_line_count: Option<serde_json::Value>,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+    #[serde(rename = "validationMode", default, skip_serializing_if = "Option::is_none")]
+    pub validation_mode: Option<serde_json::Value>,
+    #[serde(rename = "detectDataType", default, skip_serializing_if = "Option::is_none")]
+    pub detect_data_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub namespaces: Option<serde_json::Value>,
+    #[serde(rename = "namespacePrefixes", default, skip_serializing_if = "Option::is_none")]
+    pub namespace_prefixes: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FormatWriteSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "recordName", default, skip_serializing_if = "Option::is_none")]
+    pub record_name: Option<String>,
+    #[serde(rename = "recordNamespace", default, skip_serializing_if = "Option::is_none")]
+    pub record_namespace: Option<String>,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "quoteAllText", default, skip_serializing_if = "Option::is_none")]
+    pub quote_all_text: Option<serde_json::Value>,
+    #[serde(rename = "fileExtension")]
+    pub file_extension: serde_json::Value,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "filePattern", default, skip_serializing_if = "Option::is_none")]
+    pub file_pattern: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JsonWriteFilePattern {
+    #[serde(rename = "setOfObjects")]
+    SetOfObjects,
+    #[serde(rename = "arrayOfObjects")]
+    ArrayOfObjects,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<DelimitedTextReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<JsonReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<XmlReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<DelimitedTextWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<JsonWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<OrcWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CopyActivityTypeProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub inputs: Vec<DatasetReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<DatasetReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivityTypeProperties {
+    pub source: CopySource,
+    pub sink: CopySink,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub translator: Option<serde_json::Value>,
+    #[serde(rename = "enableStaging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_staging: Option<serde_json::Value>,
+    #[serde(rename = "stagingSettings", default, skip_serializing_if = "Option::is_none")]
+    pub staging_settings: Option<StagingSettings>,
+    #[serde(rename = "parallelCopies", default, skip_serializing_if = "Option::is_none")]
+    pub parallel_copies: Option<serde_json::Value>,
+    #[serde(rename = "dataIntegrationUnits", default, skip_serializing_if = "Option::is_none")]
+    pub data_integration_units: Option<serde_json::Value>,
+    #[serde(rename = "enableSkipIncompatibleRow", default, skip_serializing_if = "Option::is_none")]
+    pub enable_skip_incompatible_row: Option<serde_json::Value>,
+    #[serde(rename = "redirectIncompatibleRowSettings", default, skip_serializing_if = "Option::is_none")]
+    pub redirect_incompatible_row_settings: Option<RedirectIncompatibleRowSettings>,
+    #[serde(rename = "logStorageSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_storage_settings: Option<LogStorageSettings>,
+    #[serde(rename = "logSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_settings: Option<LogSettings>,
+    #[serde(rename = "preserveRules", default, skip_serializing_if = "Vec::is_empty")]
+    pub preserve_rules: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub preserve: Vec<serde_json::Value>,
+    #[serde(rename = "validateDataConsistency", default, skip_serializing_if = "Option::is_none")]
+    pub validate_data_consistency: Option<serde_json::Value>,
+    #[serde(rename = "skipErrorFile", default, skip_serializing_if = "Option::is_none")]
+    pub skip_error_file: Option<SkipErrorFile>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopySource {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "sourceRetryCount", default, skip_serializing_if = "Option::is_none")]
+    pub source_retry_count: Option<serde_json::Value>,
+    #[serde(rename = "sourceRetryWait", default, skip_serializing_if = "Option::is_none")]
+    pub source_retry_wait: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinarySource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<BinaryReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TabularSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "azureTableSourceQuery", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_source_query: Option<serde_json::Value>,
+    #[serde(rename = "azureTableSourceIgnoreTableNotFound", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_source_ignore_table_not_found: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipHeaderLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_header_line_count: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "pageSize", default, skip_serializing_if = "Option::is_none")]
+    pub page_size: Option<serde_json::Value>,
+    #[serde(rename = "preferredRegions", default, skip_serializing_if = "Option::is_none")]
+    pub preferred_regions: Option<serde_json::Value>,
+    #[serde(rename = "detectDatetime", default, skip_serializing_if = "Option::is_none")]
+    pub detect_datetime: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2Source {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "readBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub read_behavior: Option<salesforce_source::ReadBehavior>,
+}
+pub mod salesforce_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ReadBehavior {
+        Query,
+        QueryAll,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "readBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub read_behavior: Option<salesforce_service_cloud_source::ReadBehavior>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+pub mod salesforce_service_cloud_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ReadBehavior {
+        Query,
+        QueryAll,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "packetSize", default, skip_serializing_if = "Option::is_none")]
+    pub packet_size: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<sap_hana_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SapHanaPartitionSettings>,
+}
+pub mod sap_hana_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PhysicalPartitionsOfTable,
+        SapHanaDynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "excludeLastRequest", default, skip_serializing_if = "Option::is_none")]
+    pub exclude_last_request: Option<serde_json::Value>,
+    #[serde(rename = "baseRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub base_request_id: Option<serde_json::Value>,
+    #[serde(rename = "customRfcReadTableFunctionModule", default, skip_serializing_if = "Option::is_none")]
+    pub custom_rfc_read_table_function_module: Option<serde_json::Value>,
+    #[serde(rename = "sapDataColumnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub sap_data_column_delimiter: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "rowCount", default, skip_serializing_if = "Option::is_none")]
+    pub row_count: Option<serde_json::Value>,
+    #[serde(rename = "rowSkips", default, skip_serializing_if = "Option::is_none")]
+    pub row_skips: Option<serde_json::Value>,
+    #[serde(rename = "rfcTableFields", default, skip_serializing_if = "Option::is_none")]
+    pub rfc_table_fields: Option<serde_json::Value>,
+    #[serde(rename = "rfcTableOptions", default, skip_serializing_if = "Option::is_none")]
+    pub rfc_table_options: Option<serde_json::Value>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "customRfcReadTableFunctionModule", default, skip_serializing_if = "Option::is_none")]
+    pub custom_rfc_read_table_function_module: Option<serde_json::Value>,
+    #[serde(rename = "sapDataColumnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub sap_data_column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<sap_table_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SapTablePartitionSettings>,
+}
+pub mod sap_table_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PartitionOnInt,
+        PartitionOnCalendarYear,
+        PartitionOnCalendarMonth,
+        PartitionOnCalendarDate,
+        PartitionOnTime,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTablePartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+    #[serde(rename = "maxPartitionsNumber", default, skip_serializing_if = "Option::is_none")]
+    pub max_partitions_number: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "requestInterval", default, skip_serializing_if = "Option::is_none")]
+    pub request_interval: Option<serde_json::Value>,
+    #[serde(rename = "httpCompressionType", default, skip_serializing_if = "Option::is_none")]
+    pub http_compression_type: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "paginationRules", default, skip_serializing_if = "Option::is_none")]
+    pub pagination_rules: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "requestInterval", default, skip_serializing_if = "Option::is_none")]
+    pub request_interval: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "isolationLevel", default, skip_serializing_if = "Option::is_none")]
+    pub isolation_level: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlMiSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlDwSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSystemSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "distcpSettings", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_settings: Option<DistcpSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DistcpSettings {
+    #[serde(rename = "resourceManagerEndpoint")]
+    pub resource_manager_endpoint: serde_json::Value,
+    #[serde(rename = "tempScriptPath")]
+    pub temp_script_path: serde_json::Value,
+    #[serde(rename = "distcpOptions", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    pub query: serde_json::Value,
+    #[serde(rename = "noTruncation", default, skip_serializing_if = "Option::is_none")]
+    pub no_truncation: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "oracleReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub oracle_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<oracle_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<OraclePartitionSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+pub mod oracle_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PhysicalPartitionsOfTable,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OraclePartitionSettings {
+    #[serde(rename = "partitionNames", default, skip_serializing_if = "Option::is_none")]
+    pub partition_names: Option<serde_json::Value>,
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "oracleReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub oracle_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<AmazonRdsForOraclePartitionSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AmazonRdsForOraclePartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOraclePartitionSettings {
+    #[serde(rename = "partitionNames", default, skip_serializing_if = "Option::is_none")]
+    pub partition_names: Option<serde_json::Value>,
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<teradata_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<TeradataPartitionSettings>,
+}
+pub mod teradata_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        Hash,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "consistencyLevel", default, skip_serializing_if = "Option::is_none")]
+    pub consistency_level: Option<cassandra_source::ConsistencyLevel>,
+}
+pub mod cassandra_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ConsistencyLevel {
+        #[serde(rename = "ALL")]
+        All,
+        #[serde(rename = "EACH_QUORUM")]
+        EachQuorum,
+        #[serde(rename = "QUORUM")]
+        Quorum,
+        #[serde(rename = "LOCAL_QUORUM")]
+        LocalQuorum,
+        #[serde(rename = "ONE")]
+        One,
+        #[serde(rename = "TWO")]
+        Two,
+        #[serde(rename = "THREE")]
+        Three,
+        #[serde(rename = "LOCAL_ONE")]
+        LocalOne,
+        #[serde(rename = "SERIAL")]
+        Serial,
+        #[serde(rename = "LOCAL_SERIAL")]
+        LocalSerial,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2Source {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCursorMethodsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sort: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skip: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365Source {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "allowedGroups", default, skip_serializing_if = "Option::is_none")]
+    pub allowed_groups: Option<serde_json::Value>,
+    #[serde(rename = "userScopeFilterUri", default, skip_serializing_if = "Option::is_none")]
+    pub user_scope_filter_uri: Option<serde_json::Value>,
+    #[serde(rename = "dateFilterColumn", default, skip_serializing_if = "Option::is_none")]
+    pub date_filter_column: Option<serde_json::Value>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<serde_json::Value>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<serde_json::Value>,
+    #[serde(rename = "outputColumns", default, skip_serializing_if = "Option::is_none")]
+    pub output_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipHeaderLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_header_line_count: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQuerySource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifySource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<netezza_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<NetezzaPartitionSettings>,
+}
+pub mod netezza_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        DataSlice,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "redshiftUnloadSettings", default, skip_serializing_if = "Option::is_none")]
+    pub redshift_unload_settings: Option<RedshiftUnloadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedshiftUnloadSettings {
+    #[serde(rename = "s3LinkedServiceName")]
+    pub s3_linked_service_name: LinkedServiceReference,
+    #[serde(rename = "bucketName")]
+    pub bucket_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "exportSettings", default, skip_serializing_if = "Option::is_none")]
+    pub export_settings: Option<SnowflakeExportCopyCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExportSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeExportCopyCommand {
+    #[serde(flatten)]
+    pub export_settings: ExportSettings,
+    #[serde(rename = "additionalCopyOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_copy_options: Option<serde_json::Value>,
+    #[serde(rename = "additionalFormatOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_format_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "exportSettings", default, skip_serializing_if = "Option::is_none")]
+    pub export_settings: Option<AzureDatabricksDeltaLakeExportCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeExportCommand {
+    #[serde(flatten)]
+    pub export_settings: ExportSettings,
+    #[serde(rename = "dateFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_format: Option<serde_json::Value>,
+    #[serde(rename = "timestampFormat", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_format: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "importSettings", default, skip_serializing_if = "Option::is_none")]
+    pub import_settings: Option<AzureDatabricksDeltaLakeImportCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeImportCommand {
+    #[serde(flatten)]
+    pub import_settings: ImportSettings,
+    #[serde(rename = "dateFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_format: Option<serde_json::Value>,
+    #[serde(rename = "timestampFormat", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_format: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoredProcedureParameter {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<StoredProcedureParameterType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum StoredProcedureParameterType {
+    String,
+    Int,
+    Int64,
+    Decimal,
+    Guid,
+    Boolean,
+    Date,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopySink {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "writeBatchSize", default, skip_serializing_if = "Option::is_none")]
+    pub write_batch_size: Option<serde_json::Value>,
+    #[serde(rename = "writeBatchTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub write_batch_timeout: Option<serde_json::Value>,
+    #[serde(rename = "sinkRetryCount", default, skip_serializing_if = "Option::is_none")]
+    pub sink_retry_count: Option<serde_json::Value>,
+    #[serde(rename = "sinkRetryWait", default, skip_serializing_if = "Option::is_none")]
+    pub sink_retry_wait: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<sap_cloud_for_customer_sink::WriteBehavior>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+pub mod sap_cloud_for_customer_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Update,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureQueueSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum CopyBehaviorType {
+    PreserveHierarchy,
+    FlattenHierarchy,
+    MergeFiles,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "azureTableDefaultPartitionKeyValue", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_default_partition_key_value: Option<serde_json::Value>,
+    #[serde(rename = "azureTablePartitionKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_partition_key_name: Option<serde_json::Value>,
+    #[serde(rename = "azureTableRowKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_row_key_name: Option<serde_json::Value>,
+    #[serde(rename = "azureTableInsertType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_insert_type: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<AvroWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<ParquetWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinarySink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "blobWriterOverwriteFiles", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_overwrite_files: Option<serde_json::Value>,
+    #[serde(rename = "blobWriterDateTimeFormat", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_date_time_format: Option<serde_json::Value>,
+    #[serde(rename = "blobWriterAddHeader", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_add_header: Option<serde_json::Value>,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSystemSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlMiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlDwSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "allowPolyBase", default, skip_serializing_if = "Option::is_none")]
+    pub allow_poly_base: Option<serde_json::Value>,
+    #[serde(rename = "polyBaseSettings", default, skip_serializing_if = "Option::is_none")]
+    pub poly_base_settings: Option<PolybaseSettings>,
+    #[serde(rename = "allowCopyCommand", default, skip_serializing_if = "Option::is_none")]
+    pub allow_copy_command: Option<serde_json::Value>,
+    #[serde(rename = "copyCommandSettings", default, skip_serializing_if = "Option::is_none")]
+    pub copy_command_settings: Option<DwCopyCommandSettings>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolybaseSettings {
+    #[serde(rename = "rejectType", default, skip_serializing_if = "Option::is_none")]
+    pub reject_type: Option<PolybaseSettingsRejectType>,
+    #[serde(rename = "rejectValue", default, skip_serializing_if = "Option::is_none")]
+    pub reject_value: Option<serde_json::Value>,
+    #[serde(rename = "rejectSampleValue", default, skip_serializing_if = "Option::is_none")]
+    pub reject_sample_value: Option<serde_json::Value>,
+    #[serde(rename = "useTypeDefault", default, skip_serializing_if = "Option::is_none")]
+    pub use_type_default: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum PolybaseSettingsRejectType {
+    #[serde(rename = "value")]
+    Value,
+    #[serde(rename = "percentage")]
+    Percentage,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DwCopyCommandSettings {
+    #[serde(rename = "defaultValues", default, skip_serializing_if = "Vec::is_empty")]
+    pub default_values: Vec<DwCopyCommandDefaultValue>,
+    #[serde(rename = "additionalOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DwCopyCommandDefaultValue {
+    #[serde(rename = "columnName", default, skip_serializing_if = "Option::is_none")]
+    pub column_name: Option<serde_json::Value>,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "importSettings", default, skip_serializing_if = "Option::is_none")]
+    pub import_settings: Option<SnowflakeImportCopyCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeImportCopyCommand {
+    #[serde(flatten)]
+    pub import_settings: ImportSettings,
+    #[serde(rename = "additionalCopyOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_copy_options: Option<serde_json::Value>,
+    #[serde(rename = "additionalFormatOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_format_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogStorageSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
+    pub log_level: Option<serde_json::Value>,
+    #[serde(rename = "enableReliableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_reliable_logging: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogSettings {
+    #[serde(rename = "enableCopyActivityLog", default, skip_serializing_if = "Option::is_none")]
+    pub enable_copy_activity_log: Option<serde_json::Value>,
+    #[serde(rename = "copyActivityLogSettings", default, skip_serializing_if = "Option::is_none")]
+    pub copy_activity_log_settings: Option<CopyActivityLogSettings>,
+    #[serde(rename = "logLocationSettings")]
+    pub log_location_settings: LogLocationSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogLocationSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivityLogSettings {
+    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
+    pub log_level: Option<serde_json::Value>,
+    #[serde(rename = "enableReliableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_reliable_logging: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StagingSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+    #[serde(rename = "enableCompression", default, skip_serializing_if = "Option::is_none")]
+    pub enable_compression: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedirectIncompatibleRowSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SkipErrorFile {
+    #[serde(rename = "fileMissing", default, skip_serializing_if = "Option::is_none")]
+    pub file_missing: Option<serde_json::Value>,
+    #[serde(rename = "dataInconsistency", default, skip_serializing_if = "Option::is_none")]
+    pub data_inconsistency: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdditionalColumns {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+    #[serde(rename = "enableAdlsSingleFileParallel", default, skip_serializing_if = "Option::is_none")]
+    pub enable_adls_single_file_parallel: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<azure_search_index_sink::WriteBehavior>,
+}
+pub mod azure_search_index_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Merge,
+        Upload,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsSinkWriteBehavior {
+    Upsert,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "ingestionMappingName", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_mapping_name: Option<serde_json::Value>,
+    #[serde(rename = "ingestionMappingAsJson", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_mapping_as_json: Option<serde_json::Value>,
+    #[serde(rename = "flushImmediately", default, skip_serializing_if = "Option::is_none")]
+    pub flush_immediately: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<salesforce_sink::WriteBehavior>,
+    #[serde(rename = "externalIdFieldName", default, skip_serializing_if = "Option::is_none")]
+    pub external_id_field_name: Option<serde_json::Value>,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+}
+pub mod salesforce_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Upsert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<salesforce_service_cloud_sink::WriteBehavior>,
+    #[serde(rename = "externalIdFieldName", default, skip_serializing_if = "Option::is_none")]
+    pub external_id_field_name: Option<serde_json::Value>,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+}
+pub mod salesforce_service_cloud_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Upsert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyTranslator {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TabularTranslator {
+    #[serde(flatten)]
+    pub copy_translator: CopyTranslator,
+    #[serde(rename = "columnMappings", default, skip_serializing_if = "Option::is_none")]
+    pub column_mappings: Option<serde_json::Value>,
+    #[serde(rename = "schemaMapping", default, skip_serializing_if = "Option::is_none")]
+    pub schema_mapping: Option<serde_json::Value>,
+    #[serde(rename = "collectionReference", default, skip_serializing_if = "Option::is_none")]
+    pub collection_reference: Option<serde_json::Value>,
+    #[serde(rename = "mapComplexValuesToString", default, skip_serializing_if = "Option::is_none")]
+    pub map_complex_values_to_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mappings: Option<serde_json::Value>,
+    #[serde(rename = "typeConversion", default, skip_serializing_if = "Option::is_none")]
+    pub type_conversion: Option<serde_json::Value>,
+    #[serde(rename = "typeConversionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub type_conversion_settings: Option<TypeConversionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypeConversionSettings {
+    #[serde(rename = "allowDataTruncation", default, skip_serializing_if = "Option::is_none")]
+    pub allow_data_truncation: Option<serde_json::Value>,
+    #[serde(rename = "treatBooleanAsNumber", default, skip_serializing_if = "Option::is_none")]
+    pub treat_boolean_as_number: Option<serde_json::Value>,
+    #[serde(rename = "dateTimeFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_time_format: Option<serde_json::Value>,
+    #[serde(rename = "dateTimeOffsetFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_time_offset_format: Option<serde_json::Value>,
+    #[serde(rename = "timeSpanFormat", default, skip_serializing_if = "Option::is_none")]
+    pub time_span_format: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub culture: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightHiveActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightHiveActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightHiveActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "scriptPath", default, skip_serializing_if = "Option::is_none")]
+    pub script_path: Option<serde_json::Value>,
+    #[serde(rename = "scriptLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub script_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub variables: Vec<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum HdInsightActivityDebugInfoOption {
+    None,
+    Always,
+    Failure,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightPigActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightPigActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightPigActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub arguments: Option<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "scriptPath", default, skip_serializing_if = "Option::is_none")]
+    pub script_path: Option<serde_json::Value>,
+    #[serde(rename = "scriptLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub script_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightMapReduceActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightMapReduceActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightMapReduceActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "className")]
+    pub class_name: serde_json::Value,
+    #[serde(rename = "jarFilePath")]
+    pub jar_file_path: serde_json::Value,
+    #[serde(rename = "jarLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub jar_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "jarLibs", default, skip_serializing_if = "Vec::is_empty")]
+    pub jar_libs: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightStreamingActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightStreamingActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightStreamingActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    pub mapper: serde_json::Value,
+    pub reducer: serde_json::Value,
+    pub input: serde_json::Value,
+    pub output: serde_json::Value,
+    #[serde(rename = "filePaths")]
+    pub file_paths: Vec<serde_json::Value>,
+    #[serde(rename = "fileLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub file_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub combiner: Option<serde_json::Value>,
+    #[serde(rename = "commandEnvironment", default, skip_serializing_if = "Vec::is_empty")]
+    pub command_environment: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightSparkActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightSparkActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightSparkActivityTypeProperties {
+    #[serde(rename = "rootPath")]
+    pub root_path: serde_json::Value,
+    #[serde(rename = "entryFilePath")]
+    pub entry_file_path: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "sparkJobLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub spark_job_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(rename = "proxyUser", default, skip_serializing_if = "Option::is_none")]
+    pub proxy_user: Option<serde_json::Value>,
+    #[serde(rename = "sparkConfig", default, skip_serializing_if = "Option::is_none")]
+    pub spark_config: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteSsisPackageActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecuteSsisPackageActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteSsisPackageActivityTypeProperties {
+    #[serde(rename = "packageLocation")]
+    pub package_location: SsisPackageLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub runtime: Option<serde_json::Value>,
+    #[serde(rename = "loggingLevel", default, skip_serializing_if = "Option::is_none")]
+    pub logging_level: Option<serde_json::Value>,
+    #[serde(rename = "environmentPath", default, skip_serializing_if = "Option::is_none")]
+    pub environment_path: Option<serde_json::Value>,
+    #[serde(rename = "executionCredential", default, skip_serializing_if = "Option::is_none")]
+    pub execution_credential: Option<SsisExecutionCredential>,
+    #[serde(rename = "connectVia")]
+    pub connect_via: IntegrationRuntimeReference,
+    #[serde(rename = "projectParameters", default, skip_serializing_if = "Option::is_none")]
+    pub project_parameters: Option<serde_json::Value>,
+    #[serde(rename = "packageParameters", default, skip_serializing_if = "Option::is_none")]
+    pub package_parameters: Option<serde_json::Value>,
+    #[serde(rename = "projectConnectionManagers", default, skip_serializing_if = "Option::is_none")]
+    pub project_connection_managers: Option<serde_json::Value>,
+    #[serde(rename = "packageConnectionManagers", default, skip_serializing_if = "Option::is_none")]
+    pub package_connection_managers: Option<serde_json::Value>,
+    #[serde(rename = "propertyOverrides", default, skip_serializing_if = "Option::is_none")]
+    pub property_overrides: Option<serde_json::Value>,
+    #[serde(rename = "logLocation", default, skip_serializing_if = "Option::is_none")]
+    pub log_location: Option<SsisLogLocation>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPackageLocation {
+    #[serde(rename = "packagePath", default, skip_serializing_if = "Option::is_none")]
+    pub package_path: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<ssis_package_location::Type>,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SsisPackageLocationTypeProperties>,
+}
+pub mod ssis_package_location {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "SSISDB")]
+        Ssisdb,
+        File,
+        InlinePackage,
+        PackageStore,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPackageLocationTypeProperties {
+    #[serde(rename = "packagePassword", default, skip_serializing_if = "Option::is_none")]
+    pub package_password: Option<SecretBase>,
+    #[serde(rename = "accessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "configurationPath", default, skip_serializing_if = "Option::is_none")]
+    pub configuration_path: Option<serde_json::Value>,
+    #[serde(rename = "configurationAccessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub configuration_access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(rename = "packageContent", default, skip_serializing_if = "Option::is_none")]
+    pub package_content: Option<serde_json::Value>,
+    #[serde(rename = "packageLastModifiedDate", default, skip_serializing_if = "Option::is_none")]
+    pub package_last_modified_date: Option<String>,
+    #[serde(rename = "childPackages", default, skip_serializing_if = "Vec::is_empty")]
+    pub child_packages: Vec<SsisChildPackage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisConnectionManager {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisExecutionParameter {
+    pub value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPropertyOverride {
+    pub value: serde_json::Value,
+    #[serde(rename = "isSensitive", default, skip_serializing_if = "Option::is_none")]
+    pub is_sensitive: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisExecutionCredential {
+    pub domain: serde_json::Value,
+    #[serde(rename = "userName")]
+    pub user_name: serde_json::Value,
+    pub password: SecureString,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisAccessCredential {
+    pub domain: serde_json::Value,
+    #[serde(rename = "userName")]
+    pub user_name: serde_json::Value,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisChildPackage {
+    #[serde(rename = "packagePath")]
+    pub package_path: serde_json::Value,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(rename = "packageContent")]
+    pub package_content: serde_json::Value,
+    #[serde(rename = "packageLastModifiedDate", default, skip_serializing_if = "Option::is_none")]
+    pub package_last_modified_date: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisLogLocation {
+    #[serde(rename = "logPath")]
+    pub log_path: serde_json::Value,
+    #[serde(rename = "type")]
+    pub type_: ssis_log_location::Type,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SsisLogLocationTypeProperties,
+}
+pub mod ssis_log_location {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        File,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisLogLocationTypeProperties {
+    #[serde(rename = "accessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "logRefreshInterval", default, skip_serializing_if = "Option::is_none")]
+    pub log_refresh_interval: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CustomActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivityTypeProperties {
+    pub command: serde_json::Value,
+    #[serde(rename = "resourceLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub resource_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "referenceObjects", default, skip_serializing_if = "Option::is_none")]
+    pub reference_objects: Option<CustomActivityReferenceObject>,
+    #[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<serde_json::Value>,
+    #[serde(rename = "retentionTimeInDays", default, skip_serializing_if = "Option::is_none")]
+    pub retention_time_in_days: Option<serde_json::Value>,
+    #[serde(rename = "autoUserSpecification", default, skip_serializing_if = "Option::is_none")]
+    pub auto_user_specification: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivityReferenceObject {
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerStoredProcedureActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlServerStoredProcedureActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerStoredProcedureActivityTypeProperties {
+    #[serde(rename = "storedProcedureName")]
+    pub stored_procedure_name: serde_json::Value,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutePipelineActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecutePipelineActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutePipelineActivityTypeProperties {
+    pub pipeline: PipelineReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+    #[serde(rename = "waitOnCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub wait_on_completion: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DeleteActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteActivityTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<i64>,
+    #[serde(rename = "enableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_logging: Option<serde_json::Value>,
+    #[serde(rename = "logStorageSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_storage_settings: Option<LogStorageSettings>,
+    pub dataset: DatasetReference,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCommandActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerCommandActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCommandActivityTypeProperties {
+    pub command: serde_json::Value,
+    #[serde(rename = "commandTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub command_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LookupActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: LookupActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LookupActivityTypeProperties {
+    pub source: CopySource,
+    pub dataset: DatasetReference,
+    #[serde(rename = "firstRowOnly", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_only: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum WebActivityMethod {
+    #[serde(rename = "GET")]
+    Get,
+    #[serde(rename = "POST")]
+    Post,
+    #[serde(rename = "PUT")]
+    Put,
+    #[serde(rename = "DELETE")]
+    Delete,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivityAuthentication {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pfx: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivityTypeProperties {
+    pub method: WebActivityMethod,
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<WebActivityAuthentication>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetReference>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceReference>,
+    #[serde(rename = "connectVia", default, skip_serializing_if = "Option::is_none")]
+    pub connect_via: Option<IntegrationRuntimeReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetMetadataActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GetMetadataActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetMetadataActivityTypeProperties {
+    pub dataset: DatasetReference,
+    #[serde(rename = "fieldList", default, skip_serializing_if = "Vec::is_empty")]
+    pub field_list: Vec<serde_json::Value>,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<FormatReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IfConditionActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: IfConditionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IfConditionActivityTypeProperties {
+    pub expression: Expression,
+    #[serde(rename = "ifTrueActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub if_true_activities: Vec<Activity>,
+    #[serde(rename = "ifFalseActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub if_false_activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SwitchActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchActivityTypeProperties {
+    pub on: Expression,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub cases: Vec<SwitchCase>,
+    #[serde(rename = "defaultActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub default_activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchCase {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ForEachActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ForEachActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ForEachActivityTypeProperties {
+    #[serde(rename = "isSequential", default, skip_serializing_if = "Option::is_none")]
+    pub is_sequential: Option<bool>,
+    #[serde(rename = "batchCount", default, skip_serializing_if = "Option::is_none")]
+    pub batch_count: Option<i64>,
+    pub items: Expression,
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlBatchExecutionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlBatchExecutionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlBatchExecutionActivityTypeProperties {
+    #[serde(rename = "globalParameters", default, skip_serializing_if = "Option::is_none")]
+    pub global_parameters: Option<serde_json::Value>,
+    #[serde(rename = "webServiceOutputs", default, skip_serializing_if = "Option::is_none")]
+    pub web_service_outputs: Option<serde_json::Value>,
+    #[serde(rename = "webServiceInputs", default, skip_serializing_if = "Option::is_none")]
+    pub web_service_inputs: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlWebServiceFile {
+    #[serde(rename = "filePath")]
+    pub file_path: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlUpdateResourceActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlUpdateResourceActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlUpdateResourceActivityTypeProperties {
+    #[serde(rename = "trainedModelName")]
+    pub trained_model_name: serde_json::Value,
+    #[serde(rename = "trainedModelLinkedServiceName")]
+    pub trained_model_linked_service_name: LinkedServiceReference,
+    #[serde(rename = "trainedModelFilePath")]
+    pub trained_model_file_path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlExecutePipelineActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlExecutePipelineActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlExecutePipelineActivityTypeProperties {
+    #[serde(rename = "mlPipelineId")]
+    pub ml_pipeline_id: serde_json::Value,
+    #[serde(rename = "experimentName", default, skip_serializing_if = "Option::is_none")]
+    pub experiment_name: Option<serde_json::Value>,
+    #[serde(rename = "mlPipelineParameters", default, skip_serializing_if = "Option::is_none")]
+    pub ml_pipeline_parameters: Option<serde_json::Value>,
+    #[serde(rename = "mlParentRunId", default, skip_serializing_if = "Option::is_none")]
+    pub ml_parent_run_id: Option<serde_json::Value>,
+    #[serde(rename = "continueOnStepFailure", default, skip_serializing_if = "Option::is_none")]
+    pub continue_on_step_failure: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlPipelineParameters {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsUsqlActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DataLakeAnalyticsUsqlActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsUsqlActivityTypeProperties {
+    #[serde(rename = "scriptPath")]
+    pub script_path: serde_json::Value,
+    #[serde(rename = "scriptLinkedService")]
+    pub script_linked_service: LinkedServiceReference,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<serde_json::Value>,
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<serde_json::Value>,
+    #[serde(rename = "compilationMode", default, skip_serializing_if = "Option::is_none")]
+    pub compilation_mode: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WaitActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WaitActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WaitActivityTypeProperties {
+    #[serde(rename = "waitTimeInSeconds")]
+    pub wait_time_in_seconds: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UntilActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: UntilActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UntilActivityTypeProperties {
+    pub expression: Expression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ValidationActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ValidationActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ValidationActivityTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sleep: Option<serde_json::Value>,
+    #[serde(rename = "minimumSize", default, skip_serializing_if = "Option::is_none")]
+    pub minimum_size: Option<serde_json::Value>,
+    #[serde(rename = "childItems", default, skip_serializing_if = "Option::is_none")]
+    pub child_items: Option<serde_json::Value>,
+    pub dataset: DatasetReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FilterActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterActivityTypeProperties {
+    pub items: Expression,
+    pub condition: Expression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksNotebookActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksNotebookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksNotebookActivityTypeProperties {
+    #[serde(rename = "notebookPath")]
+    pub notebook_path: serde_json::Value,
+    #[serde(rename = "baseParameters", default, skip_serializing_if = "Option::is_none")]
+    pub base_parameters: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkJarActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksSparkJarActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkJarActivityTypeProperties {
+    #[serde(rename = "mainClassName")]
+    pub main_class_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkPythonActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksSparkPythonActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkPythonActivityTypeProperties {
+    #[serde(rename = "pythonFile")]
+    pub python_file: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetVariableActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SetVariableActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetVariableActivityTypeProperties {
+    #[serde(rename = "variableName", default, skip_serializing_if = "Option::is_none")]
+    pub variable_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppendVariableActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AppendVariableActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppendVariableActivityTypeProperties {
+    #[serde(rename = "variableName", default, skip_serializing_if = "Option::is_none")]
+    pub variable_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AzureFunctionActivityMethod {
+    #[serde(rename = "GET")]
+    Get,
+    #[serde(rename = "POST")]
+    Post,
+    #[serde(rename = "PUT")]
+    Put,
+    #[serde(rename = "DELETE")]
+    Delete,
+    #[serde(rename = "OPTIONS")]
+    Options,
+    #[serde(rename = "HEAD")]
+    Head,
+    #[serde(rename = "TRACE")]
+    Trace,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFunctionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionActivityTypeProperties {
+    pub method: AzureFunctionActivityMethod,
+    #[serde(rename = "functionName")]
+    pub function_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebHookActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebHookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum WebHookActivityMethod {
+    #[serde(rename = "POST")]
+    Post,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebHookActivityTypeProperties {
+    pub method: WebHookActivityMethod,
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<WebActivityAuthentication>,
+    #[serde(rename = "reportStatusOnCallBack", default, skip_serializing_if = "Option::is_none")]
+    pub report_status_on_call_back: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteDataFlowActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecuteDataFlowActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteDataFlowActivityTypeProperties {
+    pub dataflow: DataFlowReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<DataFlowStagingInfo>,
+    #[serde(rename = "integrationRuntime", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime: Option<IntegrationRuntimeReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<execute_data_flow_activity_type_properties::Compute>,
+    #[serde(rename = "traceLevel", default, skip_serializing_if = "Option::is_none")]
+    pub trace_level: Option<serde_json::Value>,
+    #[serde(rename = "continueOnError", default, skip_serializing_if = "Option::is_none")]
+    pub continue_on_error: Option<serde_json::Value>,
+    #[serde(rename = "runConcurrently", default, skip_serializing_if = "Option::is_none")]
+    pub run_concurrently: Option<serde_json::Value>,
+}
+pub mod execute_data_flow_activity_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Compute {
+        #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+        pub compute_type: Option<compute::ComputeType>,
+        #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+        pub core_count: Option<i64>,
+    }
+    pub mod compute {
+        use super::*;
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        pub enum ComputeType {
+            General,
+            MemoryOptimized,
+            ComputeOptimized,
+        }
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SqlPartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SapHanaPartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    SapHanaDynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SapTablePartitionOption {
+    None,
+    PartitionOnInt,
+    PartitionOnCalendarYear,
+    PartitionOnCalendarMonth,
+    PartitionOnCalendarDate,
+    PartitionOnTime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum OraclePartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TeradataPartitionOption {
+    None,
+    Hash,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum NetezzaPartitionOption {
+    None,
+    DataSlice,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SynapseNotebookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookActivityTypeProperties {
+    pub notebook: SynapseNotebookReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobDefinitionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SynapseSparkJobActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobActivityTypeProperties {
+    #[serde(rename = "sparkJob")]
+    pub spark_job: SynapseSparkJobReference,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolStoredProcedureActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+    #[serde(rename = "sqlPool")]
+    pub sql_pool: SqlPoolReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlPoolStoredProcedureActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolStoredProcedureActivityTypeProperties {
+    #[serde(rename = "storedProcedureName")]
+    pub stored_procedure_name: serde_json::Value,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkConfigurationListResponse {
+    pub value: Vec<SparkConfigurationResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkConfigurationResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: SparkConfiguration,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkConfiguration {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub configs: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub notes: Option<String>,
+    #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
+    pub created_by: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub created: Option<String>,
+    #[serde(rename = "configMergeRule", default, skip_serializing_if = "Option::is_none")]
+    pub config_merge_rule: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinitionsListResponse {
+    pub value: Vec<SparkJobDefinitionResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinitionResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: SparkJobDefinition,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinition {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "targetBigDataPool")]
+    pub target_big_data_pool: BigDataPoolReference,
+    #[serde(rename = "requiredSparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub required_spark_version: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    #[serde(rename = "jobProperties")]
+    pub job_properties: SparkJobProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<spark_job_definition::Folder>,
+}
+pub mod spark_job_definition {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    pub file: String,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(rename = "driverMemory")]
+    pub driver_memory: String,
+    #[serde(rename = "driverCores")]
+    pub driver_cores: i64,
+    #[serde(rename = "executorMemory")]
+    pub executor_memory: String,
+    #[serde(rename = "executorCores")]
+    pub executor_cores: i64,
+    #[serde(rename = "numExecutors")]
+    pub num_executors: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptsListResponse {
+    pub value: Vec<SqlScriptResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    pub properties: SqlScript,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScript {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<sql_script::Type>,
+    pub content: SqlScriptContent,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<sql_script::Folder>,
+}
+pub mod sql_script {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlQuery,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptContent {
+    pub query: String,
+    #[serde(rename = "currentConnection", default, skip_serializing_if = "Option::is_none")]
+    pub current_connection: Option<SqlConnection>,
+    #[serde(rename = "resultLimit", default, skip_serializing_if = "Option::is_none")]
+    pub result_limit: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<SqlScriptMetadata>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptMetadata {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlConnection {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<sql_connection::Type>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "poolName", default, skip_serializing_if = "Option::is_none")]
+    pub pool_name: Option<String>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+}
+pub mod sql_connection {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlOnDemand,
+        SqlPool,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerListResponse {
+    pub value: Vec<TriggerResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Trigger,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRunsQueryResponse {
+    pub value: Vec<TriggerRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRun {
+    #[serde(rename = "triggerRunId", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_run_id: Option<String>,
+    #[serde(rename = "triggerName", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_name: Option<String>,
+    #[serde(rename = "triggerType", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_type: Option<String>,
+    #[serde(rename = "triggerRunTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_run_timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<trigger_run::Status>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(rename = "triggeredPipelines", default, skip_serializing_if = "Option::is_none")]
+    pub triggered_pipelines: Option<serde_json::Value>,
+}
+pub mod trigger_run {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Succeeded,
+        Failed,
+        Inprogress,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerSubscriptionOperationStatus {
+    #[serde(rename = "triggerName", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<trigger_subscription_operation_status::Status>,
+}
+pub mod trigger_subscription_operation_status {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Enabled,
+        Provisioning,
+        Deprovisioning,
+        Disabled,
+        Unknown,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureEntityResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Resource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceInfoListResult {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<BigDataPoolResourceInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceInfo {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<BigDataPoolResourceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceProperties {
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "autoScale", default, skip_serializing_if = "Option::is_none")]
+    pub auto_scale: Option<AutoScaleProperties>,
+    #[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
+    pub creation_date: Option<String>,
+    #[serde(rename = "autoPause", default, skip_serializing_if = "Option::is_none")]
+    pub auto_pause: Option<AutoPauseProperties>,
+    #[serde(rename = "isComputeIsolationEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_compute_isolation_enabled: Option<bool>,
+    #[serde(rename = "sessionLevelPackagesEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub session_level_packages_enabled: Option<bool>,
+    #[serde(rename = "cacheSize", default, skip_serializing_if = "Option::is_none")]
+    pub cache_size: Option<i32>,
+    #[serde(rename = "dynamicExecutorAllocation", default, skip_serializing_if = "Option::is_none")]
+    pub dynamic_executor_allocation: Option<DynamicExecutorAllocation>,
+    #[serde(rename = "sparkEventsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub spark_events_folder: Option<String>,
+    #[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub node_count: Option<i32>,
+    #[serde(rename = "libraryRequirements", default, skip_serializing_if = "Option::is_none")]
+    pub library_requirements: Option<LibraryRequirements>,
+    #[serde(rename = "customLibraries", default, skip_serializing_if = "Vec::is_empty")]
+    pub custom_libraries: Vec<LibraryInfo>,
+    #[serde(rename = "sparkConfigProperties", default, skip_serializing_if = "Option::is_none")]
+    pub spark_config_properties: Option<LibraryRequirements>,
+    #[serde(rename = "sparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub spark_version: Option<String>,
+    #[serde(rename = "defaultSparkLogFolder", default, skip_serializing_if = "Option::is_none")]
+    pub default_spark_log_folder: Option<String>,
+    #[serde(rename = "nodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub node_size: Option<big_data_pool_resource_properties::NodeSize>,
+    #[serde(rename = "nodeSizeFamily", default, skip_serializing_if = "Option::is_none")]
+    pub node_size_family: Option<big_data_pool_resource_properties::NodeSizeFamily>,
+    #[serde(rename = "lastSucceededTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub last_succeeded_timestamp: Option<String>,
+}
+pub mod big_data_pool_resource_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum NodeSize {
+        None,
+        Small,
+        Medium,
+        Large,
+        XLarge,
+        #[serde(rename = "XXLarge")]
+        XxLarge,
+        #[serde(rename = "XXXLarge")]
+        XxxLarge,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum NodeSizeFamily {
+        None,
+        MemoryOptimized,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AutoScaleProperties {
+    #[serde(rename = "minNodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub min_node_count: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(rename = "maxNodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub max_node_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AutoPauseProperties {
+    #[serde(rename = "delayInMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub delay_in_minutes: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicExecutorAllocation {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryRequirements {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filename: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "containerName", default, skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+    #[serde(rename = "uploadedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub uploaded_timestamp: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<String>,
+    #[serde(rename = "creatorId", default, skip_serializing_if = "Option::is_none")]
+    pub creator_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TrackedResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub location: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorResponse>,
+    #[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_info: Vec<ErrorAdditionalInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorAdditionalInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntime {
+    #[serde(rename = "type")]
+    pub type_: IntegrationRuntimeType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum IntegrationRuntimeType {
+    Managed,
+    SelfHosted,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeListResponse {
+    pub value: Vec<IntegrationRuntimeResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: IntegrationRuntime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJob {
+    #[serde(rename = "livyInfo", default, skip_serializing_if = "Option::is_none")]
+    pub livy_info: Option<SparkBatchJobState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "workspaceName", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_name: Option<String>,
+    #[serde(rename = "sparkPoolName", default, skip_serializing_if = "Option::is_none")]
+    pub spark_pool_name: Option<String>,
+    #[serde(rename = "submitterName", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_name: Option<String>,
+    #[serde(rename = "submitterId", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<spark_batch_job::JobType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<spark_batch_job::Result>,
+    #[serde(rename = "schedulerInfo", default, skip_serializing_if = "Option::is_none")]
+    pub scheduler_info: Option<SparkScheduler>,
+    #[serde(rename = "pluginInfo", default, skip_serializing_if = "Option::is_none")]
+    pub plugin_info: Option<SparkServicePlugin>,
+    #[serde(rename = "errorInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_info: Vec<SparkServiceError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub id: i32,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appInfo", default, skip_serializing_if = "Option::is_none")]
+    pub app_info: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub log: Vec<String>,
+}
+pub mod spark_batch_job {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum JobType {
+        SparkBatch,
+        SparkSession,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        Uncertain,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobState {
+    #[serde(rename = "notStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub not_started_at: Option<String>,
+    #[serde(rename = "startingAt", default, skip_serializing_if = "Option::is_none")]
+    pub starting_at: Option<String>,
+    #[serde(rename = "runningAt", default, skip_serializing_if = "Option::is_none")]
+    pub running_at: Option<String>,
+    #[serde(rename = "deadAt", default, skip_serializing_if = "Option::is_none")]
+    pub dead_at: Option<String>,
+    #[serde(rename = "successAt", default, skip_serializing_if = "Option::is_none")]
+    pub success_at: Option<String>,
+    #[serde(rename = "killedAt", default, skip_serializing_if = "Option::is_none")]
+    pub killed_at: Option<String>,
+    #[serde(rename = "recoveringAt", default, skip_serializing_if = "Option::is_none")]
+    pub recovering_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+    #[serde(rename = "jobCreationRequest", default, skip_serializing_if = "Option::is_none")]
+    pub job_creation_request: Option<SparkRequest>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub file: Option<String>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkScheduler {
+    #[serde(rename = "submittedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submitted_at: Option<String>,
+    #[serde(rename = "scheduledAt", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_at: Option<String>,
+    #[serde(rename = "endedAt", default, skip_serializing_if = "Option::is_none")]
+    pub ended_at: Option<String>,
+    #[serde(rename = "cancellationRequestedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_requested_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_scheduler::CurrentState>,
+}
+pub mod spark_scheduler {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Queued,
+        Scheduled,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServicePlugin {
+    #[serde(rename = "preparationStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub preparation_started_at: Option<String>,
+    #[serde(rename = "resourceAcquisitionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub resource_acquisition_started_at: Option<String>,
+    #[serde(rename = "submissionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submission_started_at: Option<String>,
+    #[serde(rename = "monitoringStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub monitoring_started_at: Option<String>,
+    #[serde(rename = "cleanupStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cleanup_started_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_service_plugin::CurrentState>,
+}
+pub mod spark_service_plugin {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Preparation,
+        ResourceAcquisition,
+        Queued,
+        Submission,
+        Monitoring,
+        Cleanup,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServiceError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<spark_service_error::Source>,
+}
+pub mod spark_service_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Source {
+        System,
+        User,
+        Unknown,
+        Dependency,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolInfoListResult {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<SqlPool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPool {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<Sku>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<SqlPoolResourceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Sku {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tier: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub capacity: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolResourceProperties {
+    #[serde(rename = "maxSizeBytes", default, skip_serializing_if = "Option::is_none")]
+    pub max_size_bytes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collation: Option<String>,
+    #[serde(rename = "sourceDatabaseId", default, skip_serializing_if = "Option::is_none")]
+    pub source_database_id: Option<String>,
+    #[serde(rename = "recoverableDatabaseId", default, skip_serializing_if = "Option::is_none")]
+    pub recoverable_database_id: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "restorePointInTime", default, skip_serializing_if = "Option::is_none")]
+    pub restore_point_in_time: Option<String>,
+    #[serde(rename = "createMode", default, skip_serializing_if = "Option::is_none")]
+    pub create_mode: Option<sql_pool_resource_properties::CreateMode>,
+    #[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
+    pub creation_date: Option<String>,
+}
+pub mod sql_pool_resource_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CreateMode {
+        Default,
+        PointInTimeRestore,
+        Recovery,
+        Restore,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Workspace {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<WorkspaceProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<ManagedIdentity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceProperties {
+    #[serde(rename = "defaultDataLakeStorage", default, skip_serializing_if = "Option::is_none")]
+    pub default_data_lake_storage: Option<DataLakeStorageAccountDetails>,
+    #[serde(rename = "sqlAdministratorLoginPassword", default, skip_serializing_if = "Option::is_none")]
+    pub sql_administrator_login_password: Option<String>,
+    #[serde(rename = "managedResourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub managed_resource_group_name: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "sqlAdministratorLogin", default, skip_serializing_if = "Option::is_none")]
+    pub sql_administrator_login: Option<String>,
+    #[serde(rename = "virtualNetworkProfile", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_network_profile: Option<VirtualNetworkProfile>,
+    #[serde(rename = "connectivityEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub connectivity_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "managedVirtualNetwork", default, skip_serializing_if = "Option::is_none")]
+    pub managed_virtual_network: Option<String>,
+    #[serde(rename = "privateEndpointConnections", default, skip_serializing_if = "Vec::is_empty")]
+    pub private_endpoint_connections: Vec<PrivateEndpointConnection>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encryption: Option<EncryptionDetails>,
+    #[serde(rename = "workspaceUID", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_uid: Option<String>,
+    #[serde(rename = "extraProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extra_properties: Option<serde_json::Value>,
+    #[serde(rename = "managedVirtualNetworkSettings", default, skip_serializing_if = "Option::is_none")]
+    pub managed_virtual_network_settings: Option<ManagedVirtualNetworkSettings>,
+    #[serde(rename = "workspaceRepositoryConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_repository_configuration: Option<WorkspaceRepositoryConfiguration>,
+    #[serde(rename = "purviewConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub purview_configuration: Option<PurviewConfiguration>,
+    #[serde(rename = "adlaResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub adla_resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeStorageAccountDetails {
+    #[serde(rename = "accountUrl", default, skip_serializing_if = "Option::is_none")]
+    pub account_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filesystem: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualNetworkProfile {
+    #[serde(rename = "computeSubnetId", default, skip_serializing_if = "Option::is_none")]
+    pub compute_subnet_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpointConnection {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<PrivateEndpointConnectionProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpointConnectionProperties {
+    #[serde(rename = "privateEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub private_endpoint: Option<PrivateEndpoint>,
+    #[serde(rename = "privateLinkServiceConnectionState", default, skip_serializing_if = "Option::is_none")]
+    pub private_link_service_connection_state: Option<PrivateLinkServiceConnectionState>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpoint {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateLinkServiceConnectionState {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "actionsRequired", default, skip_serializing_if = "Option::is_none")]
+    pub actions_required: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProxyResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionDetails {
+    #[serde(rename = "doubleEncryptionEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub double_encryption_enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cmk: Option<CustomerManagedKeyDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomerManagedKeyDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<WorkspaceKeyDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceKeyDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "keyVaultUrl", default, skip_serializing_if = "Option::is_none")]
+    pub key_vault_url: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedVirtualNetworkSettings {
+    #[serde(rename = "preventDataExfiltration", default, skip_serializing_if = "Option::is_none")]
+    pub prevent_data_exfiltration: Option<bool>,
+    #[serde(rename = "linkedAccessCheckOnTargetResource", default, skip_serializing_if = "Option::is_none")]
+    pub linked_access_check_on_target_resource: Option<bool>,
+    #[serde(rename = "allowedAadTenantIdsForLinking", default, skip_serializing_if = "Vec::is_empty")]
+    pub allowed_aad_tenant_ids_for_linking: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceRepositoryConfiguration {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<String>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<String>,
+    #[serde(rename = "projectName", default, skip_serializing_if = "Option::is_none")]
+    pub project_name: Option<String>,
+    #[serde(rename = "repositoryName", default, skip_serializing_if = "Option::is_none")]
+    pub repository_name: Option<String>,
+    #[serde(rename = "collaborationBranch", default, skip_serializing_if = "Option::is_none")]
+    pub collaboration_branch: Option<String>,
+    #[serde(rename = "rootFolder", default, skip_serializing_if = "Option::is_none")]
+    pub root_folder: Option<String>,
+    #[serde(rename = "lastCommitId", default, skip_serializing_if = "Option::is_none")]
+    pub last_commit_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<GitHubClientSecret>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubClientSecret {
+    #[serde(rename = "byoaSecretAkvUrl", default, skip_serializing_if = "Option::is_none")]
+    pub byoa_secret_akv_url: Option<String>,
+    #[serde(rename = "byoaSecretName", default, skip_serializing_if = "Option::is_none")]
+    pub byoa_secret_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PurviewConfiguration {
+    #[serde(rename = "purviewResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub purview_resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedIdentity {
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<managed_identity::Type>,
+}
+pub mod managed_identity {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        None,
+        SystemAssigned,
+    }
+}
diff --git a/services/svc/synapse/src/package_artifacts_2021_06_01_preview/operations.rs b/services/svc/synapse/src/package_artifacts_2021_06_01_preview/operations.rs
new file mode 100644
index 0000000000..9b34105cb8
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_2021_06_01_preview/operations.rs
@@ -0,0 +1,5728 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod big_data_pools {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<BigDataPoolResourceInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/bigDataPools", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BigDataPoolResourceInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        big_data_pool_name: &str,
+    ) -> std::result::Result<BigDataPoolResourceInfo, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/bigDataPools/{}", operation_config.base_path(), big_data_pool_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BigDataPoolResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_flow {
+    use crate::models::*;
+    pub async fn get_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<DataFlowResource, get_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(get_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        if_match: Option<&str>,
+        data_flow: &DataFlowResource,
+    ) -> std::result::Result<create_or_update_data_flow::Response, create_or_update_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(data_flow).map_err(create_or_update_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_data_flow::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_data_flow::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DataFlowResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+    ) -> std::result::Result<delete_data_flow::Response, delete_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_data_flow::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_data_flow::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_data_flow::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_data_flow::Response, rename_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}/rename", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_data_flow::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_data_flow::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_data_flows_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<DataFlowListResponse, get_data_flows_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_data_flows_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_data_flows_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_data_flows_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_data_flows_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_data_flows_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_data_flows_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_data_flows_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_data_flows_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_flow_debug_session {
+    use crate::models::*;
+    pub async fn create_data_flow_debug_session(
+        operation_config: &crate::OperationConfig,
+        request: &CreateDataFlowDebugSessionRequest,
+    ) -> std::result::Result<create_data_flow_debug_session::Response, create_data_flow_debug_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/createDataFlowDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(create_data_flow_debug_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_data_flow_debug_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(create_data_flow_debug_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_data_flow_debug_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_data_flow_debug_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(create_data_flow_debug_session::Response::Accepted202),
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: CreateDataFlowDebugSessionResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_data_flow_debug_session::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_data_flow_debug_session::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_data_flow_debug_session {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            Ok200(CreateDataFlowDebugSessionResponse),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_data_flow_debug_sessions_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<QueryDataFlowDebugSessionsResponse, query_data_flow_debug_sessions_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryDataFlowDebugSessions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_data_flow_debug_sessions_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_data_flow_debug_sessions_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_data_flow_debug_sessions_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_data_flow_debug_sessions_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryDataFlowDebugSessionsResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_data_flow_debug_sessions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_data_flow_debug_sessions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_data_flow_debug_sessions_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_data_flow_debug_sessions_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_data_flow(
+        operation_config: &crate::OperationConfig,
+        request: &DataFlowDebugPackage,
+    ) -> std::result::Result<AddDataFlowToDebugSessionResponse, add_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/addDataFlowToDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(add_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(add_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AddDataFlowToDebugSessionResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_data_flow_debug_session(
+        operation_config: &crate::OperationConfig,
+        request: &DeleteDataFlowDebugSessionRequest,
+    ) -> std::result::Result<(), delete_data_flow_debug_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deleteDataFlowDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(delete_data_flow_debug_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_data_flow_debug_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(delete_data_flow_debug_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_data_flow_debug_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_data_flow_debug_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_data_flow_debug_session::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_data_flow_debug_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_command(
+        operation_config: &crate::OperationConfig,
+        request: &DataFlowDebugCommandRequest,
+    ) -> std::result::Result<execute_command::Response, execute_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/executeDataFlowDebugCommand", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(execute_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(execute_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(execute_command::Response::Accepted202),
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowDebugCommandResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_command::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_command::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_command {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            Ok200(DataFlowDebugCommandResponse),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod dataset {
+    use crate::models::*;
+    pub async fn get_datasets_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<DatasetListResponse, get_datasets_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_datasets_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_datasets_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_datasets_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_datasets_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_datasets_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_datasets_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_datasets_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_datasets_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<DatasetResource, get_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(get_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_dataset::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        if_match: Option<&str>,
+        dataset: &DatasetResource,
+    ) -> std::result::Result<create_or_update_dataset::Response, create_or_update_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(dataset).map_err(create_or_update_dataset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_dataset::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_dataset::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DatasetResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+    ) -> std::result::Result<delete_dataset::Response, delete_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_dataset::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_dataset::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_dataset::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_dataset::Response, rename_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}/rename", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_dataset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_dataset::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_dataset::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| rename_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod linked_service {
+    use crate::models::*;
+    pub async fn get_linked_services_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<LinkedServiceListResponse, get_linked_services_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_linked_services_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_linked_services_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_linked_services_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_linked_services_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_services_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_services_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_linked_services_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_linked_services_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<LinkedServiceResource, get_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(get_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_linked_service::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        if_match: Option<&str>,
+        linked_service: &LinkedServiceResource,
+    ) -> std::result::Result<create_or_update_linked_service::Response, create_or_update_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(linked_service).map_err(create_or_update_linked_service::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_linked_service::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_linked_service::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(LinkedServiceResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+    ) -> std::result::Result<delete_linked_service::Response, delete_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_linked_service::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_linked_service::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_linked_service::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_linked_service::Response, rename_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}/rename", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_linked_service::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_linked_service::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_linked_service::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod workspace_git_repo_management {
+    use crate::models::*;
+    pub async fn get_git_hub_access_token(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+        git_hub_access_token_request: &GitHubAccessTokenRequest,
+    ) -> std::result::Result<GitHubAccessTokenResponse, get_git_hub_access_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/getGitHubAccessToken", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_git_hub_access_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_git_hub_access_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        let req_body = azure_core::to_json(git_hub_access_token_request).map_err(get_git_hub_access_token::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_git_hub_access_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_git_hub_access_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GitHubAccessTokenResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_git_hub_access_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_git_hub_access_token::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_git_hub_access_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod integration_runtimes {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<IntegrationRuntimeListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/integrationRuntimes", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IntegrationRuntimeListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        integration_runtime_name: &str,
+    ) -> std::result::Result<IntegrationRuntimeResource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/integrationRuntimes/{}", operation_config.base_path(), integration_runtime_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IntegrationRuntimeResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod library {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<LibraryListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn flush(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<flush::Response, flush::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}/flush", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(flush::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(flush::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(flush::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(flush::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(flush::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| flush::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(flush::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| flush::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(flush::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod flush {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_operation_result(
+        operation_config: &crate::OperationConfig,
+        operation_id: &str,
+    ) -> std::result::Result<get_operation_result::Response, get_operation_result::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraryOperationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get_operation_result::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_operation_result::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_operation_result::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_operation_result::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(get_operation_result::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: OperationResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(get_operation_result::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_operation_result::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_operation_result {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(LibraryResource),
+            Accepted202(OperationResult),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, library_name: &str) -> std::result::Result<LibraryResource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<create::Response, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(create::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::CONFLICT => Err(delete::Error::Conflict409 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Conflict409 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod notebook {
+    use crate::models::*;
+    pub async fn get_notebooks_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<NotebookListResponse, get_notebooks_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_notebooks_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebooks_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_notebooks_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebooks_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebooks_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebooks_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebooks_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebooks_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_notebook_summary_by_work_space(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<NotebookListResponse, get_notebook_summary_by_work_space::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooksSummary", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_notebook_summary_by_work_space::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebook_summary_by_work_space::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_notebook_summary_by_work_space::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebook_summary_by_work_space::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebook_summary_by_work_space::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebook_summary_by_work_space::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebook_summary_by_work_space::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebook_summary_by_work_space {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<NotebookResource, get_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(get_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_notebook::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        if_match: Option<&str>,
+        notebook: &NotebookResource,
+    ) -> std::result::Result<create_or_update_notebook::Response, create_or_update_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(notebook).map_err(create_or_update_notebook::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_notebook::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_notebook::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(NotebookResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+    ) -> std::result::Result<delete_notebook::Response, delete_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_notebook::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_notebook::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_notebook::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_notebook::Response, rename_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}/rename", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_notebook::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_notebook::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_notebook::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod notebook_operation_result {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, operation_id: &str) -> std::result::Result<get::Response, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebookOperationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(get::Response::Ok200),
+            http::StatusCode::CREATED => Ok(get::Response::Created201),
+            http::StatusCode::ACCEPTED => Ok(get::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(get::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Created201,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod operation_result {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, operation_id: &str) -> std::result::Result<get::Response, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/operationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(get::Response::Ok200),
+            http::StatusCode::CREATED => Ok(get::Response::Created201),
+            http::StatusCode::ACCEPTED => Ok(get::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(get::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Created201,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod operation_status {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, operation_id: &str) -> std::result::Result<get::Response, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/operationStatuses/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(get::Response::Ok200),
+            http::StatusCode::CREATED => Ok(get::Response::Created201),
+            http::StatusCode::ACCEPTED => Ok(get::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(get::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Created201,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline {
+    use crate::models::*;
+    pub async fn get_pipelines_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<PipelineListResponse, get_pipelines_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_pipelines_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipelines_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_pipelines_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipelines_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipelines_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipelines_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipelines_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipelines_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<PipelineResource, get_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(get_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_pipeline::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        if_match: Option<&str>,
+        pipeline: &PipelineResource,
+    ) -> std::result::Result<create_or_update_pipeline::Response, create_or_update_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(pipeline).map_err(create_or_update_pipeline::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_pipeline::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_pipeline::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(PipelineResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+    ) -> std::result::Result<delete_pipeline::Response, delete_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_pipeline::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_pipeline::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_pipeline::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_pipeline::Response, rename_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}/rename", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_pipeline::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_pipeline::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_pipeline::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        reference_pipeline_run_id: Option<&str>,
+        is_recovery: Option<bool>,
+        start_activity_name: Option<&str>,
+        parameters: Option<&ParameterValueSpecification>,
+    ) -> std::result::Result<CreateRunResponse, create_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}/createRun", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(create_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(reference_pipeline_run_id) = reference_pipeline_run_id {
+            url.query_pairs_mut()
+                .append_pair("referencePipelineRunId", reference_pipeline_run_id);
+        }
+        if let Some(is_recovery) = is_recovery {
+            url.query_pairs_mut().append_pair("isRecovery", is_recovery.to_string().as_str());
+        }
+        if let Some(start_activity_name) = start_activity_name {
+            url.query_pairs_mut().append_pair("startActivityName", start_activity_name);
+        }
+        let req_body = if let Some(parameters) = parameters {
+            azure_core::to_json(parameters).map_err(create_pipeline_run::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: CreateRunResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline_run {
+    use crate::models::*;
+    pub async fn query_pipeline_runs_by_workspace(
+        operation_config: &crate::OperationConfig,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<PipelineRunsQueryResponse, query_pipeline_runs_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryPipelineRuns", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_pipeline_runs_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_pipeline_runs_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_pipeline_runs_by_workspace::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_pipeline_runs_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_pipeline_runs_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_pipeline_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_pipeline_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_pipeline_runs_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_pipeline_runs_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        run_id: &str,
+    ) -> std::result::Result<PipelineRun, get_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelineruns/{}", operation_config.base_path(), run_id);
+        let mut url = url::Url::parse(url_str).map_err(get_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineRun = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_activity_runs(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        run_id: &str,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<ActivityRunsQueryResponse, query_activity_runs::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/pipelines/{}/pipelineruns/{}/queryActivityruns",
+            operation_config.base_path(),
+            pipeline_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(query_activity_runs::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_activity_runs::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_activity_runs::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query_activity_runs::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_activity_runs::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ActivityRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_activity_runs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_activity_runs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_activity_runs::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_activity_runs {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        run_id: &str,
+        is_recursive: Option<bool>,
+    ) -> std::result::Result<(), cancel_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelineruns/{}/cancel", operation_config.base_path(), run_id);
+        let mut url = url::Url::parse(url_str).map_err(cancel_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(is_recursive) = is_recursive {
+            url.query_pairs_mut().append_pair("isRecursive", is_recursive.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod spark_configuration {
+    use crate::models::*;
+    pub async fn get_spark_configurations_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SparkConfigurationListResponse, get_spark_configurations_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkconfigurations", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_configurations_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_configurations_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_configurations_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_configurations_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkConfigurationListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_configurations_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_configurations_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_configurations_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_configurations_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_configuration(
+        operation_config: &crate::OperationConfig,
+        spark_configuration_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SparkConfigurationResource, get_spark_configuration::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkconfigurations/{}", operation_config.base_path(), spark_configuration_name);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_configuration::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_configuration::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_configuration::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_configuration::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkConfigurationResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_spark_configuration::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_configuration::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_configuration {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_spark_configuration(
+        operation_config: &crate::OperationConfig,
+        spark_configuration_name: &str,
+        if_match: Option<&str>,
+        spark_configuration: &SparkConfigurationResource,
+    ) -> std::result::Result<create_or_update_spark_configuration::Response, create_or_update_spark_configuration::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkconfigurations/{}", operation_config.base_path(), spark_configuration_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_spark_configuration::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_spark_configuration::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(spark_configuration).map_err(create_or_update_spark_configuration::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_spark_configuration::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_spark_configuration::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkConfigurationResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_spark_configuration::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_spark_configuration::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_spark_configuration::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_spark_configuration {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SparkConfigurationResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_spark_configuration(
+        operation_config: &crate::OperationConfig,
+        spark_configuration_name: &str,
+    ) -> std::result::Result<delete_spark_configuration::Response, delete_spark_configuration::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkconfigurations/{}", operation_config.base_path(), spark_configuration_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_spark_configuration::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_spark_configuration::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_spark_configuration::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_spark_configuration::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_spark_configuration::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_spark_configuration::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_spark_configuration::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_spark_configuration::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_spark_configuration {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_spark_configuration(
+        operation_config: &crate::OperationConfig,
+        spark_configuration_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_spark_configuration::Response, rename_spark_configuration::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkconfigurations/{}/rename",
+            operation_config.base_path(),
+            spark_configuration_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(rename_spark_configuration::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_spark_configuration::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_spark_configuration::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_spark_configuration::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_spark_configuration::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_spark_configuration::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_spark_configuration::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_spark_configuration::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_spark_configuration {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod spark_job_definition {
+    use crate::models::*;
+    pub async fn get_spark_job_definitions_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SparkJobDefinitionsListResponse, get_spark_job_definitions_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_definitions_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_definitions_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_job_definitions_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_definitions_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definitions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definitions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_job_definitions_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_definitions_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SparkJobDefinitionResource, get_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_spark_job_definition::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        if_match: Option<&str>,
+        spark_job_definition: &SparkJobDefinitionResource,
+    ) -> std::result::Result<create_or_update_spark_job_definition::Response, create_or_update_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(spark_job_definition).map_err(create_or_update_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_spark_job_definition::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SparkJobDefinitionResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+    ) -> std::result::Result<delete_spark_job_definition::Response, delete_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_spark_job_definition::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_spark_job_definition::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_spark_job_definition::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+    ) -> std::result::Result<execute_spark_job_definition::Response, execute_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkJobDefinitions/{}/execute",
+            operation_config.base_path(),
+            spark_job_definition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(execute_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(execute_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_spark_job_definition::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202(SparkBatchJob),
+            Ok200(SparkBatchJob),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_spark_job_definition::Response, rename_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkJobDefinitions/{}/rename",
+            operation_config.base_path(),
+            spark_job_definition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(rename_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_spark_job_definition::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_spark_job_definition::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn debug_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_azure_resource: &SparkJobDefinitionResource,
+    ) -> std::result::Result<debug_spark_job_definition::Response, debug_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/debugSparkJobDefinition", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(debug_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(debug_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body =
+            azure_core::to_json(spark_job_definition_azure_resource).map_err(debug_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(debug_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(debug_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(debug_spark_job_definition::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(debug_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(debug_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod debug_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202(SparkBatchJob),
+            Ok200(SparkBatchJob),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod sql_pools {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<SqlPoolInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlPools", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlPoolInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, sql_pool_name: &str) -> std::result::Result<SqlPool, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlPools/{}", operation_config.base_path(), sql_pool_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlPool =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod sql_script {
+    use crate::models::*;
+    pub async fn get_sql_scripts_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SqlScriptsListResponse, get_sql_scripts_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_scripts_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_scripts_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_sql_scripts_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_scripts_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_scripts_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_scripts_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_sql_scripts_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_sql_scripts_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SqlScriptResource, get_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_sql_script::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        if_match: Option<&str>,
+        sql_script: &SqlScriptResource,
+    ) -> std::result::Result<create_or_update_sql_script::Response, create_or_update_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(sql_script).map_err(create_or_update_sql_script::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_sql_script::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_sql_script::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SqlScriptResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+    ) -> std::result::Result<delete_sql_script::Response, delete_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_sql_script::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_sql_script::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_sql_script::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_sql_script::Response, rename_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}/rename", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_sql_script::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_sql_script::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_sql_script::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod trigger {
+    use crate::models::*;
+    pub async fn get_triggers_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<TriggerListResponse, get_triggers_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_triggers_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_triggers_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_triggers_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_triggers_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_triggers_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_triggers_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_triggers_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_triggers_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<TriggerResource, get_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(get_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_trigger::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        if_match: Option<&str>,
+        trigger: &TriggerResource,
+    ) -> std::result::Result<create_or_update_trigger::Response, create_or_update_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(trigger).map_err(create_or_update_trigger::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_trigger::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_trigger::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<delete_trigger::Response, delete_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_trigger::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_trigger::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_trigger::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn subscribe_trigger_to_events(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<subscribe_trigger_to_events::Response, subscribe_trigger_to_events::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/subscribeToEvents", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(subscribe_trigger_to_events::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(subscribe_trigger_to_events::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(subscribe_trigger_to_events::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(subscribe_trigger_to_events::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| subscribe_trigger_to_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(subscribe_trigger_to_events::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(subscribe_trigger_to_events::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| subscribe_trigger_to_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(subscribe_trigger_to_events::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod subscribe_trigger_to_events {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerSubscriptionOperationStatus),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_event_subscription_status(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<TriggerSubscriptionOperationStatus, get_event_subscription_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/getEventSubscriptionStatus",
+            operation_config.base_path(),
+            trigger_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_event_subscription_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_event_subscription_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_event_subscription_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_event_subscription_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_subscription_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_subscription_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_event_subscription_status::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_event_subscription_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn unsubscribe_trigger_from_events(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<unsubscribe_trigger_from_events::Response, unsubscribe_trigger_from_events::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/unsubscribeFromEvents", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(unsubscribe_trigger_from_events::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(unsubscribe_trigger_from_events::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(unsubscribe_trigger_from_events::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(unsubscribe_trigger_from_events::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| unsubscribe_trigger_from_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(unsubscribe_trigger_from_events::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(unsubscribe_trigger_from_events::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| unsubscribe_trigger_from_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(unsubscribe_trigger_from_events::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod unsubscribe_trigger_from_events {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerSubscriptionOperationStatus),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn start_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<(), start_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/start", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(start_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(start_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(start_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(start_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| start_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(start_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod start_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn stop_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<(), stop_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/stop", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(stop_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(stop_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(stop_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(stop_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| stop_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(stop_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod stop_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod trigger_run {
+    use crate::models::*;
+    pub async fn rerun_trigger_instance(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<(), rerun_trigger_instance::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/triggerRuns/{}/rerun",
+            operation_config.base_path(),
+            trigger_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(rerun_trigger_instance::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rerun_trigger_instance::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rerun_trigger_instance::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rerun_trigger_instance::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rerun_trigger_instance::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rerun_trigger_instance::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rerun_trigger_instance {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_trigger_instance(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<(), cancel_trigger_instance::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/triggerRuns/{}/cancel",
+            operation_config.base_path(),
+            trigger_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_trigger_instance::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_trigger_instance::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(cancel_trigger_instance::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_trigger_instance::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_trigger_instance::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_trigger_instance::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_trigger_instance {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_trigger_runs_by_workspace(
+        operation_config: &crate::OperationConfig,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<TriggerRunsQueryResponse, query_trigger_runs_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryTriggerRuns", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_trigger_runs_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_trigger_runs_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_trigger_runs_by_workspace::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_trigger_runs_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_trigger_runs_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_trigger_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_trigger_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_trigger_runs_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_trigger_runs_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod workspace {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig) -> std::result::Result<Workspace, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/workspace", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Workspace =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_artifacts_composite_v1/mod.rs b/services/svc/synapse/src/package_artifacts_composite_v1/mod.rs
new file mode 100644
index 0000000000..ed72a17404
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_composite_v1/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-06-01-preview";
diff --git a/services/svc/synapse/src/package_artifacts_composite_v1/models.rs b/services/svc/synapse/src/package_artifacts_composite_v1/models.rs
new file mode 100644
index 0000000000..0d923b714b
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_composite_v1/models.rs
@@ -0,0 +1,9529 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KqlScriptsResourceCollectionResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<KqlScriptResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KqlScriptResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<KqlScript>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KqlScript {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub content: Option<kql_script::Content>,
+}
+pub mod kql_script {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Content {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub query: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub metadata: Option<content::Metadata>,
+        #[serde(rename = "currentConnection", default, skip_serializing_if = "Option::is_none")]
+        pub current_connection: Option<content::CurrentConnection>,
+    }
+    pub mod content {
+        use super::*;
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        pub struct Metadata {
+            #[serde(default, skip_serializing_if = "Option::is_none")]
+            pub language: Option<String>,
+        }
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        pub struct CurrentConnection {
+            #[serde(default, skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+            pub type_: Option<String>,
+        }
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkConfigurationListResponse {
+    pub value: Vec<SparkConfigurationResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkConfigurationResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: SparkConfiguration,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkConfiguration {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub configs: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub notes: Option<String>,
+    #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
+    pub created_by: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub created: Option<String>,
+    #[serde(rename = "configMergeRule", default, skip_serializing_if = "Option::is_none")]
+    pub config_merge_rule: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubResource {
+    #[serde(flatten)]
+    pub azure_entity_resource: AzureEntityResource,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SubResourceDebugResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Expression {
+    #[serde(rename = "type")]
+    pub type_: expression::Type,
+    pub value: String,
+}
+pub mod expression {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Expression,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecureString {
+    #[serde(flatten)]
+    pub secret_base: SecretBase,
+    pub value: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultSecretReference {
+    #[serde(flatten)]
+    pub secret_base: SecretBase,
+    pub store: LinkedServiceReference,
+    #[serde(rename = "secretName")]
+    pub secret_name: serde_json::Value,
+    #[serde(rename = "secretVersion", default, skip_serializing_if = "Option::is_none")]
+    pub secret_version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SecretBase {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeReference {
+    #[serde(rename = "type")]
+    pub type_: integration_runtime_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod integration_runtime_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        IntegrationRuntimeReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudError {
+    pub error: CloudErrorBody,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CloudErrorBody {
+    pub code: String,
+    pub message: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<CloudError>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerDependencyProvisioningStatus {
+    #[serde(rename = "triggerName")]
+    pub trigger_name: String,
+    #[serde(rename = "provisioningStatus")]
+    pub provisioning_status: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VariableDefinitionSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VariableSpecification {
+    #[serde(rename = "type")]
+    pub type_: variable_specification::Type,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+pub mod variable_specification {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        String,
+        Bool,
+        Boolean,
+        Array,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterDefinitionSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterSpecification {
+    #[serde(rename = "type")]
+    pub type_: parameter_specification::Type,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+pub mod parameter_specification {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        Object,
+        String,
+        Int,
+        Float,
+        Bool,
+        Array,
+        SecureString,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterValueSpecification {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineReference {
+    #[serde(rename = "type")]
+    pub type_: pipeline_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+}
+pub mod pipeline_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        PipelineReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerPipelineReference {
+    #[serde(rename = "pipelineReference", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_reference: Option<PipelineReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceUpdateParameters {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<WorkspaceIdentity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceIdentity {
+    #[serde(rename = "type")]
+    pub type_: workspace_identity::Type,
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+}
+pub mod workspace_identity {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SystemAssigned,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetReference {
+    #[serde(rename = "type")]
+    pub type_: dataset_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod dataset_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        DatasetReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceReference {
+    #[serde(rename = "type")]
+    pub type_: linked_service_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+pub mod linked_service_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        LinkedServiceReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowReference {
+    #[serde(rename = "type")]
+    pub type_: data_flow_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+    #[serde(rename = "datasetParameters", default, skip_serializing_if = "Option::is_none")]
+    pub dataset_parameters: Option<serde_json::Value>,
+}
+pub mod data_flow_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        DataFlowReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowStagingInfo {
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunFilterParameters {
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+    #[serde(rename = "lastUpdatedAfter")]
+    pub last_updated_after: String,
+    #[serde(rename = "lastUpdatedBefore")]
+    pub last_updated_before: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub filters: Vec<RunQueryFilter>,
+    #[serde(rename = "orderBy", default, skip_serializing_if = "Vec::is_empty")]
+    pub order_by: Vec<RunQueryOrderBy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunQueryFilter {
+    pub operand: run_query_filter::Operand,
+    pub operator: run_query_filter::Operator,
+    pub values: Vec<String>,
+}
+pub mod run_query_filter {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operand {
+        PipelineName,
+        Status,
+        RunStart,
+        RunEnd,
+        ActivityName,
+        ActivityRunStart,
+        ActivityRunEnd,
+        ActivityType,
+        TriggerName,
+        TriggerRunTimestamp,
+        RunGroupId,
+        LatestOnly,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operator {
+        Equals,
+        NotEquals,
+        In,
+        NotIn,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RunQueryOrderBy {
+    #[serde(rename = "orderBy")]
+    pub order_by: run_query_order_by::OrderBy,
+    pub order: run_query_order_by::Order,
+}
+pub mod run_query_order_by {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OrderBy {
+        RunStart,
+        RunEnd,
+        PipelineName,
+        Status,
+        ActivityName,
+        ActivityRunStart,
+        ActivityRunEnd,
+        TriggerName,
+        TriggerRunTimestamp,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Order {
+        #[serde(rename = "ASC")]
+        Asc,
+        #[serde(rename = "DESC")]
+        Desc,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTumblingWindowTriggerActionParameters {
+    #[serde(rename = "startTime")]
+    pub start_time: String,
+    #[serde(rename = "endTime")]
+    pub end_time: String,
+    #[serde(rename = "maxConcurrency")]
+    pub max_concurrency: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTriggerListResponse {
+    pub value: Vec<RerunTriggerResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTriggerResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: RerunTumblingWindowTrigger,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetSsisObjectMetadataRequest {
+    #[serde(rename = "metadataPath", default, skip_serializing_if = "Option::is_none")]
+    pub metadata_path: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisObjectMetadataStatusResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExposureControlRequest {
+    #[serde(rename = "featureName", default, skip_serializing_if = "Option::is_none")]
+    pub feature_name: Option<String>,
+    #[serde(rename = "featureType", default, skip_serializing_if = "Option::is_none")]
+    pub feature_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExposureControlResponse {
+    #[serde(rename = "featureName", default, skip_serializing_if = "Option::is_none")]
+    pub feature_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookReference {
+    #[serde(rename = "type")]
+    pub type_: synapse_notebook_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod synapse_notebook_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        NotebookReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobReference {
+    #[serde(rename = "type")]
+    pub type_: synapse_spark_job_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod synapse_spark_job_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SparkJobDefinitionReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolReference {
+    #[serde(rename = "type")]
+    pub type_: sql_pool_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod sql_pool_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlPoolReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ArtifactRenameRequest {
+    #[serde(rename = "newName", default, skip_serializing_if = "Option::is_none")]
+    pub new_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Trigger {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "runtimeState", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_state: Option<TriggerRuntimeState>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TriggerRuntimeState {
+    Started,
+    Stopped,
+    Disabled,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MultiplePipelineTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub pipelines: Vec<TriggerPipelineReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScheduleTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: schedule_trigger::TypeProperties,
+}
+pub mod schedule_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        pub recurrence: ScheduleTriggerRecurrence,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScheduleTriggerRecurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub frequency: Option<RecurrenceFrequency>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub interval: Option<i32>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(rename = "timeZone", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schedule: Option<RecurrenceSchedule>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum RecurrenceFrequency {
+    NotSpecified,
+    Minute,
+    Hour,
+    Day,
+    Week,
+    Month,
+    Year,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceSchedule {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub minutes: Vec<i32>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub hours: Vec<i32>,
+    #[serde(rename = "weekDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub week_days: Vec<String>,
+    #[serde(rename = "monthDays", default, skip_serializing_if = "Vec::is_empty")]
+    pub month_days: Vec<i32>,
+    #[serde(rename = "monthlyOccurrences", default, skip_serializing_if = "Vec::is_empty")]
+    pub monthly_occurrences: Vec<RecurrenceScheduleOccurrence>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RecurrenceScheduleOccurrence {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub day: Option<DayOfWeek>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub occurrence: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DayOfWeek {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: blob_trigger::TypeProperties,
+}
+pub mod blob_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "folderPath")]
+        pub folder_path: String,
+        #[serde(rename = "maxConcurrency")]
+        pub max_concurrency: i64,
+        #[serde(rename = "linkedService")]
+        pub linked_service: LinkedServiceReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobEventsTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: blob_events_trigger::TypeProperties,
+}
+pub mod blob_events_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "blobPathBeginsWith", default, skip_serializing_if = "Option::is_none")]
+        pub blob_path_begins_with: Option<String>,
+        #[serde(rename = "blobPathEndsWith", default, skip_serializing_if = "Option::is_none")]
+        pub blob_path_ends_with: Option<String>,
+        #[serde(rename = "ignoreEmptyBlobs", default, skip_serializing_if = "Option::is_none")]
+        pub ignore_empty_blobs: Option<bool>,
+        pub events: BlobEventTypes,
+        pub scope: String,
+    }
+}
+pub type BlobEventTypes = Vec<String>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomEventsTrigger {
+    #[serde(flatten)]
+    pub multiple_pipeline_trigger: MultiplePipelineTrigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: custom_events_trigger::TypeProperties,
+}
+pub mod custom_events_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "subjectBeginsWith", default, skip_serializing_if = "Option::is_none")]
+        pub subject_begins_with: Option<String>,
+        #[serde(rename = "subjectEndsWith", default, skip_serializing_if = "Option::is_none")]
+        pub subject_ends_with: Option<String>,
+        pub events: Vec<serde_json::Value>,
+        pub scope: String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TumblingWindowTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    pub pipeline: TriggerPipelineReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: tumbling_window_trigger::TypeProperties,
+}
+pub mod tumbling_window_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        pub frequency: TumblingWindowFrequency,
+        pub interval: i32,
+        #[serde(rename = "startTime")]
+        pub start_time: String,
+        #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+        pub end_time: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub delay: Option<serde_json::Value>,
+        #[serde(rename = "maxConcurrency")]
+        pub max_concurrency: i64,
+        #[serde(rename = "retryPolicy", default, skip_serializing_if = "Option::is_none")]
+        pub retry_policy: Option<RetryPolicy>,
+        #[serde(rename = "dependsOn", default, skip_serializing_if = "Vec::is_empty")]
+        pub depends_on: Vec<DependencyReference>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TumblingWindowFrequency {
+    Minute,
+    Hour,
+    Month,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RetryPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub count: Option<serde_json::Value>,
+    #[serde(rename = "intervalInSeconds", default, skip_serializing_if = "Option::is_none")]
+    pub interval_in_seconds: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerReference {
+    #[serde(rename = "type")]
+    pub type_: trigger_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod trigger_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        TriggerReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DependencyReference {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerDependencyReference {
+    #[serde(flatten)]
+    pub dependency_reference: DependencyReference,
+    #[serde(rename = "referenceTrigger")]
+    pub reference_trigger: TriggerReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TumblingWindowTriggerDependencyReference {
+    #[serde(flatten)]
+    pub trigger_dependency_reference: TriggerDependencyReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offset: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SelfDependencyTumblingWindowTriggerReference {
+    #[serde(flatten)]
+    pub dependency_reference: DependencyReference,
+    pub offset: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RerunTumblingWindowTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: rerun_tumbling_window_trigger::TypeProperties,
+}
+pub mod rerun_tumbling_window_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "parentTrigger")]
+        pub parent_trigger: serde_json::Value,
+        #[serde(rename = "requestedStartTime")]
+        pub requested_start_time: String,
+        #[serde(rename = "requestedEndTime")]
+        pub requested_end_time: String,
+        #[serde(rename = "rerunConcurrency")]
+        pub rerun_concurrency: i64,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ChainingTrigger {
+    #[serde(flatten)]
+    pub trigger: Trigger,
+    pub pipeline: TriggerPipelineReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: chaining_trigger::TypeProperties,
+}
+pub mod chaining_trigger {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct TypeProperties {
+        #[serde(rename = "dependsOn")]
+        pub depends_on: Vec<PipelineReference>,
+        #[serde(rename = "runDimension")]
+        pub run_dimension: String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowListResponse {
+    pub value: Vec<DataFlowResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: DataFlow,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateDataFlowDebugSessionRequest {
+    #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+    pub compute_type: Option<String>,
+    #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+    pub core_count: Option<i64>,
+    #[serde(rename = "timeToLive", default, skip_serializing_if = "Option::is_none")]
+    pub time_to_live: Option<i64>,
+    #[serde(rename = "integrationRuntime", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime: Option<IntegrationRuntimeDebugResource>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: IntegrationRuntime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateDataFlowDebugSessionResponse {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryDataFlowDebugSessionsResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<DataFlowDebugSessionInfo>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugSessionInfo {
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+    pub compute_type: Option<String>,
+    #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+    pub core_count: Option<i64>,
+    #[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub node_count: Option<i64>,
+    #[serde(rename = "integrationRuntimeName", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime_name: Option<String>,
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<String>,
+    #[serde(rename = "timeToLiveInMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub time_to_live_in_minutes: Option<i64>,
+    #[serde(rename = "lastActivityTime", default, skip_serializing_if = "Option::is_none")]
+    pub last_activity_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugPackage {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlow", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow: Option<DataFlowDebugResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetDebugResource>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceDebugResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<DataFlowStagingInfo>,
+    #[serde(rename = "debugSettings", default, skip_serializing_if = "Option::is_none")]
+    pub debug_settings: Option<data_flow_debug_package::DebugSettings>,
+}
+pub mod data_flow_debug_package {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct DebugSettings {
+        #[serde(rename = "sourceSettings", default, skip_serializing_if = "Vec::is_empty")]
+        pub source_settings: Vec<DataFlowSourceSetting>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub parameters: Option<ParameterValueSpecification>,
+        #[serde(rename = "datasetParameters", default, skip_serializing_if = "Option::is_none")]
+        pub dataset_parameters: Option<serde_json::Value>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSourceSetting {
+    #[serde(rename = "sourceName", default, skip_serializing_if = "Option::is_none")]
+    pub source_name: Option<String>,
+    #[serde(rename = "rowLimit", default, skip_serializing_if = "Option::is_none")]
+    pub row_limit: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: DataFlow,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AddDataFlowToDebugSessionResponse {
+    #[serde(rename = "jobVersion", default, skip_serializing_if = "Option::is_none")]
+    pub job_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StartDataFlowDebugSessionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlow", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow: Option<DataFlowResource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetResource>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceResource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<serde_json::Value>,
+    #[serde(rename = "debugSettings", default, skip_serializing_if = "Option::is_none")]
+    pub debug_settings: Option<serde_json::Value>,
+    #[serde(rename = "incrementalDebug", default, skip_serializing_if = "Option::is_none")]
+    pub incremental_debug: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StartDataFlowDebugSessionResponse {
+    #[serde(rename = "jobVersion", default, skip_serializing_if = "Option::is_none")]
+    pub job_version: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteDataFlowDebugSessionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugPreviewDataRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugStatisticsRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EvaluateDataFlowExpressionRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(rename = "dataFlowName", default, skip_serializing_if = "Option::is_none")]
+    pub data_flow_name: Option<String>,
+    #[serde(rename = "streamName", default, skip_serializing_if = "Option::is_none")]
+    pub stream_name: Option<String>,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expression: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandRequest {
+    #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub command: Option<data_flow_debug_command_request::Command>,
+    #[serde(rename = "commandPayload", default, skip_serializing_if = "Option::is_none")]
+    pub command_payload: Option<DataFlowDebugCommandPayload>,
+}
+pub mod data_flow_debug_command_request {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Command {
+        #[serde(rename = "executePreviewQuery")]
+        ExecutePreviewQuery,
+        #[serde(rename = "executeStatisticsQuery")]
+        ExecuteStatisticsQuery,
+        #[serde(rename = "executeExpressionQuery")]
+        ExecuteExpressionQuery,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugCommandPayload {
+    #[serde(rename = "streamName")]
+    pub stream_name: String,
+    #[serde(rename = "rowLimits", default, skip_serializing_if = "Option::is_none")]
+    pub row_limits: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expression: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugQueryResponse {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowDebugResultResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceDebugResource {
+    #[serde(flatten)]
+    pub sub_resource_debug_resource: SubResourceDebugResource,
+    pub properties: LinkedService,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlow {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<data_flow::Folder>,
+}
+pub mod data_flow {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MappingDataFlow {
+    #[serde(flatten)]
+    pub data_flow: DataFlow,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MappingDataFlowTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MappingDataFlowTypeProperties {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sources: Vec<DataFlowSource>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sinks: Vec<DataFlowSink>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub transformations: Vec<Transformation>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub script: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Transformation {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSource {
+    #[serde(flatten)]
+    pub transformation: Transformation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<DatasetReference>,
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "schemaLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub schema_linked_service: Option<LinkedServiceReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataFlowSink {
+    #[serde(flatten)]
+    pub transformation: Transformation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<DatasetReference>,
+    #[serde(rename = "linkedService", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "schemaLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub schema_linked_service: Option<LinkedServiceReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetListResponse {
+    pub value: Vec<DatasetResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Dataset {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub structure: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<dataset::Folder>,
+}
+pub mod dataset {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetLocation {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub container: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "fileSystem", default, skip_serializing_if = "Option::is_none")]
+    pub file_system: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Location {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "bucketName", default, skip_serializing_if = "Option::is_none")]
+    pub bucket_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "bucketName", default, skip_serializing_if = "Option::is_none")]
+    pub bucket_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpServerLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLocation {
+    #[serde(flatten)]
+    pub dataset_location: DatasetLocation,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDataElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetSchemaDataElement {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetStorageFormat {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub serializer: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub deserializer: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TextFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+    #[serde(rename = "columnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "rowDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub row_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "escapeChar", default, skip_serializing_if = "Option::is_none")]
+    pub escape_char: Option<serde_json::Value>,
+    #[serde(rename = "quoteChar", default, skip_serializing_if = "Option::is_none")]
+    pub quote_char: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_line_count: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+    #[serde(rename = "filePattern", default, skip_serializing_if = "Option::is_none")]
+    pub file_pattern: Option<serde_json::Value>,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "jsonNodeReference", default, skip_serializing_if = "Option::is_none")]
+    pub json_node_reference: Option<serde_json::Value>,
+    #[serde(rename = "jsonPathDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub json_path_definition: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JsonFormatFilePattern {
+    #[serde(rename = "setOfObjects")]
+    SetOfObjects,
+    #[serde(rename = "arrayOfObjects")]
+    ArrayOfObjects,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetFormat {
+    #[serde(flatten)]
+    pub dataset_storage_format: DatasetStorageFormat,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetCompression {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetBZip2Compression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetGZipCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetDeflateCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetZipDeflateCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetTarCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatasetTarGZipCompression {
+    #[serde(flatten)]
+    pub dataset_compression: DatasetCompression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub level: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompressionLevel {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DatasetCompressionLevelEnum {
+    Optimal,
+    Fastest,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3Dataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonS3DatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3DatasetTypeProperties {
+    #[serde(rename = "bucketName")]
+    pub bucket_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub version: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AvroDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "avroCompressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub avro_compression_codec: Option<serde_json::Value>,
+    #[serde(rename = "avroCompressionLevel", default, skip_serializing_if = "Option::is_none")]
+    pub avro_compression_level: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AvroCompressionCodecEnum {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "deflate")]
+    Deflate,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "xz")]
+    Xz,
+    #[serde(rename = "bzip2")]
+    Bzip2,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ExcelDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "sheetName")]
+    pub sheet_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub range: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ParquetDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "compressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub compression_codec: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ParquetCompressionCodecEnum {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "gzip")]
+    Gzip,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lzo")]
+    Lzo,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DelimitedTextDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "columnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "rowDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub row_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "compressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub compression_codec: Option<serde_json::Value>,
+    #[serde(rename = "compressionLevel", default, skip_serializing_if = "Option::is_none")]
+    pub compression_level: Option<serde_json::Value>,
+    #[serde(rename = "quoteChar", default, skip_serializing_if = "Option::is_none")]
+    pub quote_char: Option<serde_json::Value>,
+    #[serde(rename = "escapeChar", default, skip_serializing_if = "Option::is_none")]
+    pub escape_char: Option<serde_json::Value>,
+    #[serde(rename = "firstRowAsHeader", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_as_header: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum CompressionCodec {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "lzo")]
+    Lzo,
+    #[serde(rename = "bzip2")]
+    Bzip2,
+    #[serde(rename = "gzip")]
+    Gzip,
+    #[serde(rename = "deflate")]
+    Deflate,
+    #[serde(rename = "zipDeflate")]
+    ZipDeflate,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lz4")]
+    Lz4,
+    #[serde(rename = "tar")]
+    Tar,
+    #[serde(rename = "tarGZip")]
+    TarGZip,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<JsonDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<XmlDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "encodingName", default, skip_serializing_if = "Option::is_none")]
+    pub encoding_name: Option<serde_json::Value>,
+    #[serde(rename = "nullValue", default, skip_serializing_if = "Option::is_none")]
+    pub null_value: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OrcDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(rename = "orcCompressionCodec", default, skip_serializing_if = "Option::is_none")]
+    pub orc_compression_codec: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum OrcCompressionCodec {
+    #[serde(rename = "none")]
+    None,
+    #[serde(rename = "zlib")]
+    Zlib,
+    #[serde(rename = "snappy")]
+    Snappy,
+    #[serde(rename = "lzo")]
+    Lzo,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<BinaryDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryDatasetTypeProperties {
+    pub location: DatasetLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureBlobDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "tableRootLocation", default, skip_serializing_if = "Option::is_none")]
+    pub table_root_location: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableDatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlMiTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureSqlDwTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<CassandraTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub keyspace: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbSqlApiCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DocumentDbCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DynamicsEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DynamicsCrmEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsEntityDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<CommonDataServiceForAppsEntityDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsEntityDatasetTypeProperties {
+    #[serde(rename = "entityName", default, skip_serializing_if = "Option::is_none")]
+    pub entity_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureDataLakeStoreDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureBlobFsDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365Dataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Office365DatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365DatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub predicate: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileShareDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<FileShareDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileShareDatasetTypeProperties {
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
+    pub file_name: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(rename = "fileFilter", default, skip_serializing_if = "Option::is_none")]
+    pub file_filter: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCollectionDatasetTypeProperties {
+    #[serde(rename = "collectionName")]
+    pub collection_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbAtlasCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasCollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2CollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbV2CollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2CollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiCollectionDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbMongoDbApiCollectionDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiCollectionDatasetTypeProperties {
+    pub collection: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ODataResourceDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataResourceDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OracleTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRdsForOracleTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<TeradataTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMySqlTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRedshiftTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2TableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<Db2TableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2TableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<RelationalTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<InformixTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<OdbcTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MySqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PostgreSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<MicrosoftAccessTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SalesforceObjectDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceObjectDatasetTypeProperties {
+    #[serde(rename = "objectApiName", default, skip_serializing_if = "Option::is_none")]
+    pub object_api_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SalesforceServiceCloudObjectDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudObjectDatasetTypeProperties {
+    #[serde(rename = "objectApiName", default, skip_serializing_if = "Option::is_none")]
+    pub object_api_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SybaseTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwCubeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapCloudForCustomerResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapEccResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SapHanaTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapOpenHubTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubTableDatasetTypeProperties {
+    #[serde(rename = "openHubDestinationName")]
+    pub open_hub_destination_name: serde_json::Value,
+    #[serde(rename = "excludeLastRequest", default, skip_serializing_if = "Option::is_none")]
+    pub exclude_last_request: Option<serde_json::Value>,
+    #[serde(rename = "baseRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub base_request_id: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SqlServerTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AmazonRdsForSqlServerTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerTableDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<RestResourceDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestResourceDatasetTypeProperties {
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "paginationRules", default, skip_serializing_if = "Option::is_none")]
+    pub pagination_rules: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapTableResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableResourceDatasetTypeProperties {
+    #[serde(rename = "tableName")]
+    pub table_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebTableDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebTableDatasetTypeProperties {
+    pub index: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSearchIndexDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexDatasetTypeProperties {
+    #[serde(rename = "indexName")]
+    pub index_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<HttpDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpDatasetTypeProperties {
+    #[serde(rename = "relativeUrl", default, skip_serializing_if = "Option::is_none")]
+    pub relative_url: Option<serde_json::Value>,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<DatasetStorageFormat>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compression: Option<DatasetCompression>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzurePostgreSqlTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<DrillDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GoogleBigQueryDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dataset: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GreenplumDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<HiveDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<ImpalaDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PhoenixDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<PrestoDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SparkDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<NetezzaTableDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaTableDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<VerticaDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaDatasetTypeProperties {
+    #[serde(rename = "tableName", default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsAxResourceDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxResourceDatasetTypeProperties {
+    pub path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerTableDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsObjectDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<GenericDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SnowflakeDatasetTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListResourceDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SharePointOnlineListDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListDatasetTypeProperties {
+    #[serde(rename = "listName", default, skip_serializing_if = "Option::is_none")]
+    pub list_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeDataset {
+    #[serde(flatten)]
+    pub dataset: Dataset,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<AzureDatabricksDeltaLakeDatasetTypeProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeDatasetTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceListResponse {
+    pub value: Vec<LinkedServiceResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedServiceResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: LinkedService,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LinkedService {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "connectVia", default, skip_serializing_if = "Option::is_none")]
+    pub connect_via: Option<IntegrationRuntimeReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBlobStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureStorageLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "serviceEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub service_endpoint: Option<String>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "accountKind", default, skip_serializing_if = "Option::is_none")]
+    pub account_kind: Option<String>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlDwLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDwLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRdsForSqlServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlDatabaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlDatabaseLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSqlMiLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlMiLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBatchLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBatchLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBatchLinkedServiceTypeProperties {
+    #[serde(rename = "accountName")]
+    pub account_name: serde_json::Value,
+    #[serde(rename = "accessKey", default, skip_serializing_if = "Option::is_none")]
+    pub access_key: Option<SecretBase>,
+    #[serde(rename = "batchUri")]
+    pub batch_uri: serde_json::Value,
+    #[serde(rename = "poolName")]
+    pub pool_name: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureKeyVaultLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureKeyVaultLinkedServiceTypeProperties {
+    #[serde(rename = "baseUrl")]
+    pub base_url: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub account_endpoint: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsDeploymentType {
+    Online,
+    OnPremisesWithIfd,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsAuthenticationType {
+    Office365,
+    Ifd,
+    #[serde(rename = "AADServicePrincipal")]
+    AadServicePrincipal,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsCrmLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ServicePrincipalCredentialEnum {
+    ServicePrincipalKey,
+    ServicePrincipalCert,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CommonDataServiceForAppsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsLinkedServiceTypeProperties {
+    #[serde(rename = "deploymentType")]
+    pub deployment_type: serde_json::Value,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
+    pub service_uri: Option<serde_json::Value>,
+    #[serde(rename = "organizationName", default, skip_serializing_if = "Option::is_none")]
+    pub organization_name: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential_type: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalCredential", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_credential: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightLinkedServiceTypeProperties {
+    #[serde(rename = "clusterUri")]
+    pub cluster_uri: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "hcatalogLinkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub hcatalog_linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "isEspEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_esp_enabled: Option<serde_json::Value>,
+    #[serde(rename = "fileSystem", default, skip_serializing_if = "Option::is_none")]
+    pub file_system: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FileServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFileStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "userId", default, skip_serializing_if = "Option::is_none")]
+    pub user_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "sasUri", default, skip_serializing_if = "Option::is_none")]
+    pub sas_uri: Option<serde_json::Value>,
+    #[serde(rename = "sasToken", default, skip_serializing_if = "Option::is_none")]
+    pub sas_token: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "fileShare", default, skip_serializing_if = "Option::is_none")]
+    pub file_share: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub snapshot: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleCloudStorageLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageLinkedServiceTypeProperties {
+    #[serde(rename = "accessKeyId", default, skip_serializing_if = "Option::is_none")]
+    pub access_key_id: Option<serde_json::Value>,
+    #[serde(rename = "secretAccessKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_access_key: Option<SecretBase>,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OracleLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRdsForLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMySqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MySqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PostgreSqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SybaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sybase_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod sybase_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Db2LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2LinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    pub server: serde_json::Value,
+    pub database: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<db2_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "packageCollection", default, skip_serializing_if = "Option::is_none")]
+    pub package_collection: Option<serde_json::Value>,
+    #[serde(rename = "certificateCommonName", default, skip_serializing_if = "Option::is_none")]
+    pub certificate_common_name: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod db2_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: TeradataLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<teradata_linked_service_type_properties::AuthenticationType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod teradata_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlLinkedServiceTypeProperties {
+    #[serde(rename = "mlEndpoint")]
+    pub ml_endpoint: serde_json::Value,
+    #[serde(rename = "apiKey")]
+    pub api_key: SecretBase,
+    #[serde(rename = "updateResourceEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub update_resource_endpoint: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlServiceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlServiceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlServiceLinkedServiceTypeProperties {
+    #[serde(rename = "subscriptionId")]
+    pub subscription_id: serde_json::Value,
+    #[serde(rename = "resourceGroupName")]
+    pub resource_group_name: serde_json::Value,
+    #[serde(rename = "mlWorkspaceName")]
+    pub ml_workspace_name: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OdbcLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: InformixLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MicrosoftAccessLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credential: Option<SecretBase>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdfsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ODataLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<o_data_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "aadResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub aad_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "aadServicePrincipalCredentialType", default, skip_serializing_if = "Option::is_none")]
+    pub aad_service_principal_credential_type: Option<o_data_linked_service_type_properties::AadServicePrincipalCredentialType>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalEmbeddedCert", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_embedded_cert: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalEmbeddedCertPassword", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_embedded_cert_password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod o_data_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        Windows,
+        AadServicePrincipal,
+        ManagedServiceIdentity,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AadServicePrincipalCredentialType {
+        ServicePrincipalKey,
+        ServicePrincipalCert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: web_linked_service_type_properties::AuthenticationType,
+}
+pub mod web_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        ClientCertificate,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebAnonymousAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebBasicAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+    pub username: serde_json::Value,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebClientCertificateAuthentication {
+    #[serde(flatten)]
+    pub web_linked_service_type_properties: WebLinkedServiceTypeProperties,
+    pub pfx: SecretBase,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CassandraLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<mongo_db_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "databaseName")]
+    pub database_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "authSource", default, skip_serializing_if = "Option::is_none")]
+    pub auth_source: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod mongo_db_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbAtlasLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MongoDbV2LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2LinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CosmosDbMongoDbApiLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    pub database: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataLakeStoreLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreLinkedServiceTypeProperties {
+    #[serde(rename = "dataLakeStoreUri")]
+    pub data_lake_store_uri: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<serde_json::Value>,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<serde_json::Value>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureBlobFsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "accountKey", default, skip_serializing_if = "Option::is_none")]
+    pub account_key: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: Office365LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365LinkedServiceTypeProperties {
+    #[serde(rename = "office365TenantId")]
+    pub office365_tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalTenantId")]
+    pub service_principal_tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceLinkedServiceTypeProperties {
+    #[serde(rename = "environmentUrl", default, skip_serializing_if = "Option::is_none")]
+    pub environment_url: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "securityToken", default, skip_serializing_if = "Option::is_none")]
+    pub security_token: Option<SecretBase>,
+    #[serde(rename = "apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceServiceCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudLinkedServiceTypeProperties {
+    #[serde(rename = "environmentUrl", default, skip_serializing_if = "Option::is_none")]
+    pub environment_url: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "securityToken", default, skip_serializing_if = "Option::is_none")]
+    pub security_token: Option<SecretBase>,
+    #[serde(rename = "apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<serde_json::Value>,
+    #[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapCloudForCustomerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapEccLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccLinkedServiceTypeProperties {
+    pub url: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapOpenHubLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "systemNumber")]
+    pub system_number: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<serde_json::Value>,
+    #[serde(rename = "systemId", default, skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "messageServer", default, skip_serializing_if = "Option::is_none")]
+    pub message_server: Option<serde_json::Value>,
+    #[serde(rename = "messageServerService", default, skip_serializing_if = "Option::is_none")]
+    pub message_server_service: Option<serde_json::Value>,
+    #[serde(rename = "logonGroup", default, skip_serializing_if = "Option::is_none")]
+    pub logon_group: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestServiceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: RestServiceLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestServiceLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: rest_service_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+    #[serde(rename = "azureCloudType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_cloud_type: Option<serde_json::Value>,
+    #[serde(rename = "aadResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub aad_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod rest_service_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Basic,
+        AadServicePrincipal,
+        ManagedServiceIdentity,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3LinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonS3LinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3LinkedServiceTypeProperties {
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<serde_json::Value>,
+    #[serde(rename = "accessKeyId", default, skip_serializing_if = "Option::is_none")]
+    pub access_key_id: Option<serde_json::Value>,
+    #[serde(rename = "secretAccessKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_access_key: Option<SecretBase>,
+    #[serde(rename = "serviceUrl", default, skip_serializing_if = "Option::is_none")]
+    pub service_url: Option<serde_json::Value>,
+    #[serde(rename = "sessionToken", default, skip_serializing_if = "Option::is_none")]
+    pub session_token: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonRedshiftLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomDataSourceLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureSearchLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HttpLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<http_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "embeddedCertData", default, skip_serializing_if = "Option::is_none")]
+    pub embedded_cert_data: Option<serde_json::Value>,
+    #[serde(rename = "certThumbprint", default, skip_serializing_if = "Option::is_none")]
+    pub cert_thumbprint: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+}
+pub mod http_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+        Digest,
+        Windows,
+        ClientCertificate,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FtpServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<ftp_server_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "enableServerCertificateValidation", default, skip_serializing_if = "Option::is_none")]
+    pub enable_server_certificate_validation: Option<serde_json::Value>,
+}
+pub mod ftp_server_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Anonymous,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpServerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SftpServerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpServerLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sftp_server_linked_service_type_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "privateKeyPath", default, skip_serializing_if = "Option::is_none")]
+    pub private_key_path: Option<serde_json::Value>,
+    #[serde(rename = "privateKeyContent", default, skip_serializing_if = "Option::is_none")]
+    pub private_key_content: Option<SecretBase>,
+    #[serde(rename = "passPhrase", default, skip_serializing_if = "Option::is_none")]
+    pub pass_phrase: Option<SecretBase>,
+    #[serde(rename = "skipHostKeyValidation", default, skip_serializing_if = "Option::is_none")]
+    pub skip_host_key_validation: Option<serde_json::Value>,
+    #[serde(rename = "hostKeyFingerprint", default, skip_serializing_if = "Option::is_none")]
+    pub host_key_fingerprint: Option<serde_json::Value>,
+}
+pub mod sftp_server_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        SshPublicKey,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapBwLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwLinkedServiceTypeProperties {
+    pub server: serde_json::Value,
+    #[serde(rename = "systemNumber")]
+    pub system_number: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapHanaLinkedServiceProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaLinkedServiceProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    pub server: serde_json::Value,
+    #[serde(rename = "authenticationType", default, skip_serializing_if = "Option::is_none")]
+    pub authentication_type: Option<sap_hana_linked_service_properties::AuthenticationType>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod sap_hana_linked_service_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        Windows,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AmazonMwsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "marketplaceID")]
+    pub marketplace_id: serde_json::Value,
+    #[serde(rename = "sellerID")]
+    pub seller_id: serde_json::Value,
+    #[serde(rename = "mwsAuthToken", default, skip_serializing_if = "Option::is_none")]
+    pub mws_auth_token: Option<SecretBase>,
+    #[serde(rename = "accessKeyId")]
+    pub access_key_id: serde_json::Value,
+    #[serde(rename = "secretKey", default, skip_serializing_if = "Option::is_none")]
+    pub secret_key: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzurePostgreSqlLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ConcurLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CouchbaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(rename = "credString", default, skip_serializing_if = "Option::is_none")]
+    pub cred_string: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DrillLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: EloquaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleBigQueryLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQueryLinkedServiceTypeProperties {
+    pub project: serde_json::Value,
+    #[serde(rename = "additionalProjects", default, skip_serializing_if = "Option::is_none")]
+    pub additional_projects: Option<serde_json::Value>,
+    #[serde(rename = "requestGoogleDriveScope", default, skip_serializing_if = "Option::is_none")]
+    pub request_google_drive_scope: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: google_big_query_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub email: Option<serde_json::Value>,
+    #[serde(rename = "keyFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub key_file_path: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod google_big_query_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        ServiceAuthentication,
+        UserAuthentication,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GreenplumLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HBaseLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: h_base_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod h_base_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Basic,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HiveLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "serverType", default, skip_serializing_if = "Option::is_none")]
+    pub server_type: Option<hive_linked_service_type_properties::ServerType>,
+    #[serde(rename = "thriftTransportProtocol", default, skip_serializing_if = "Option::is_none")]
+    pub thrift_transport_protocol: Option<hive_linked_service_type_properties::ThriftTransportProtocol>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: hive_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "serviceDiscoveryMode", default, skip_serializing_if = "Option::is_none")]
+    pub service_discovery_mode: Option<serde_json::Value>,
+    #[serde(rename = "zooKeeperNameSpace", default, skip_serializing_if = "Option::is_none")]
+    pub zoo_keeper_name_space: Option<serde_json::Value>,
+    #[serde(rename = "useNativeQuery", default, skip_serializing_if = "Option::is_none")]
+    pub use_native_query: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod hive_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServerType {
+        HiveServer1,
+        HiveServer2,
+        HiveThriftServer,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ThriftTransportProtocol {
+        Binary,
+        #[serde(rename = "SASL")]
+        Sasl,
+        #[serde(rename = "HTTP ")]
+        Http,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Username,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HubspotLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotLinkedServiceTypeProperties {
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ImpalaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: impala_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod impala_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        #[serde(rename = "SASLUsername")]
+        SaslUsername,
+        UsernameAndPassword,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: JiraLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    pub username: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MagentoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MariaDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMariaDbLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: MarketoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PaypalLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PhoenixLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: phoenix_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod phoenix_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: PrestoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "serverVersion")]
+    pub server_version: serde_json::Value,
+    pub catalog: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub port: Option<serde_json::Value>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: presto_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "timeZoneID", default, skip_serializing_if = "Option::is_none")]
+    pub time_zone_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod presto_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        #[serde(rename = "LDAP")]
+        Ldap,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: QuickBooksLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "companyId")]
+    pub company_id: serde_json::Value,
+    #[serde(rename = "consumerKey")]
+    pub consumer_key: serde_json::Value,
+    #[serde(rename = "consumerSecret")]
+    pub consumer_secret: SecretBase,
+    #[serde(rename = "accessToken")]
+    pub access_token: SecretBase,
+    #[serde(rename = "accessTokenSecret")]
+    pub access_token_secret: SecretBase,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ServiceNowLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: service_now_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod service_now_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Basic,
+        OAuth2,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ShopifyLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifyLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SparkLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    pub port: serde_json::Value,
+    #[serde(rename = "serverType", default, skip_serializing_if = "Option::is_none")]
+    pub server_type: Option<spark_linked_service_type_properties::ServerType>,
+    #[serde(rename = "thriftTransportProtocol", default, skip_serializing_if = "Option::is_none")]
+    pub thrift_transport_protocol: Option<spark_linked_service_type_properties::ThriftTransportProtocol>,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: spark_linked_service_type_properties::AuthenticationType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "httpPath", default, skip_serializing_if = "Option::is_none")]
+    pub http_path: Option<serde_json::Value>,
+    #[serde(rename = "enableSsl", default, skip_serializing_if = "Option::is_none")]
+    pub enable_ssl: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "allowHostNameCNMismatch", default, skip_serializing_if = "Option::is_none")]
+    pub allow_host_name_cn_mismatch: Option<serde_json::Value>,
+    #[serde(rename = "allowSelfSignedServerCert", default, skip_serializing_if = "Option::is_none")]
+    pub allow_self_signed_server_cert: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod spark_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ServerType {
+        SharkServer,
+        SharkServer2,
+        SparkThriftServer,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ThriftTransportProtocol {
+        Binary,
+        #[serde(rename = "SASL")]
+        Sasl,
+        #[serde(rename = "HTTP ")]
+        Http,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        Anonymous,
+        Username,
+        UsernameAndPassword,
+        #[serde(rename = "WindowsAzureHDInsightService")]
+        WindowsAzureHdInsightService,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SquareLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub host: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "redirectUri")]
+    pub redirect_uri: serde_json::Value,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: XeroLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub host: serde_json::Value,
+    #[serde(rename = "consumerKey", default, skip_serializing_if = "Option::is_none")]
+    pub consumer_key: Option<SecretBase>,
+    #[serde(rename = "privateKey", default, skip_serializing_if = "Option::is_none")]
+    pub private_key: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ZohoLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: VerticaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: NetezzaLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString", default, skip_serializing_if = "Option::is_none")]
+    pub connection_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pwd: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SalesforceMarketingCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudLinkedServiceTypeProperties {
+    #[serde(rename = "connectionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub connection_properties: Option<serde_json::Value>,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightOnDemandLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightOnDemandLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightOnDemandLinkedServiceTypeProperties {
+    #[serde(rename = "clusterSize")]
+    pub cluster_size: serde_json::Value,
+    #[serde(rename = "timeToLive")]
+    pub time_to_live: serde_json::Value,
+    pub version: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(rename = "hostSubscriptionId")]
+    pub host_subscription_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "clusterResourceGroup")]
+    pub cluster_resource_group: serde_json::Value,
+    #[serde(rename = "clusterNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_name_prefix: Option<serde_json::Value>,
+    #[serde(rename = "clusterUserName", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_user_name: Option<serde_json::Value>,
+    #[serde(rename = "clusterPassword", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_password: Option<SecretBase>,
+    #[serde(rename = "clusterSshUserName", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_ssh_user_name: Option<serde_json::Value>,
+    #[serde(rename = "clusterSshPassword", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_ssh_password: Option<SecretBase>,
+    #[serde(rename = "additionalLinkedServiceNames", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_linked_service_names: Vec<LinkedServiceReference>,
+    #[serde(rename = "hcatalogLinkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub hcatalog_linked_service_name: Option<LinkedServiceReference>,
+    #[serde(rename = "clusterType", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_type: Option<serde_json::Value>,
+    #[serde(rename = "sparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub spark_version: Option<serde_json::Value>,
+    #[serde(rename = "coreConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub core_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hBaseConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub h_base_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hdfsConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub hdfs_configuration: Option<serde_json::Value>,
+    #[serde(rename = "hiveConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub hive_configuration: Option<serde_json::Value>,
+    #[serde(rename = "mapReduceConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub map_reduce_configuration: Option<serde_json::Value>,
+    #[serde(rename = "oozieConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub oozie_configuration: Option<serde_json::Value>,
+    #[serde(rename = "stormConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub storm_configuration: Option<serde_json::Value>,
+    #[serde(rename = "yarnConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub yarn_configuration: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "headNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub head_node_size: Option<serde_json::Value>,
+    #[serde(rename = "dataNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub data_node_size: Option<serde_json::Value>,
+    #[serde(rename = "zookeeperNodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub zookeeper_node_size: Option<serde_json::Value>,
+    #[serde(rename = "scriptActions", default, skip_serializing_if = "Vec::is_empty")]
+    pub script_actions: Vec<ScriptAction>,
+    #[serde(rename = "virtualNetworkId", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_network_id: Option<serde_json::Value>,
+    #[serde(rename = "subnetName", default, skip_serializing_if = "Option::is_none")]
+    pub subnet_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ScriptAction {
+    pub name: String,
+    pub uri: String,
+    pub roles: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum HdiNodeTypes {
+    Headnode,
+    Workernode,
+    Zookeeper,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeAnalyticsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataLakeAnalyticsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeAnalyticsLinkedServiceTypeProperties {
+    #[serde(rename = "accountName")]
+    pub account_name: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
+    pub subscription_id: Option<serde_json::Value>,
+    #[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub resource_group_name: Option<serde_json::Value>,
+    #[serde(rename = "dataLakeAnalyticsUri", default, skip_serializing_if = "Option::is_none")]
+    pub data_lake_analytics_uri: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDatabricksLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksLinkedServiceTypeProperties {
+    pub domain: serde_json::Value,
+    #[serde(rename = "accessToken", default, skip_serializing_if = "Option::is_none")]
+    pub access_token: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<serde_json::Value>,
+    #[serde(rename = "workspaceResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_resource_id: Option<serde_json::Value>,
+    #[serde(rename = "existingClusterId", default, skip_serializing_if = "Option::is_none")]
+    pub existing_cluster_id: Option<serde_json::Value>,
+    #[serde(rename = "instancePoolId", default, skip_serializing_if = "Option::is_none")]
+    pub instance_pool_id: Option<serde_json::Value>,
+    #[serde(rename = "newClusterVersion", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_version: Option<serde_json::Value>,
+    #[serde(rename = "newClusterNumOfWorker", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_num_of_worker: Option<serde_json::Value>,
+    #[serde(rename = "newClusterNodeType", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_node_type: Option<serde_json::Value>,
+    #[serde(rename = "newClusterSparkConf", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_spark_conf: Option<serde_json::Value>,
+    #[serde(rename = "newClusterSparkEnvVars", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_spark_env_vars: Option<serde_json::Value>,
+    #[serde(rename = "newClusterCustomTags", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_custom_tags: Option<serde_json::Value>,
+    #[serde(rename = "newClusterLogDestination", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_log_destination: Option<serde_json::Value>,
+    #[serde(rename = "newClusterDriverNodeType", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_driver_node_type: Option<serde_json::Value>,
+    #[serde(rename = "newClusterInitScripts", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_init_scripts: Option<serde_json::Value>,
+    #[serde(rename = "newClusterEnableElasticDisk", default, skip_serializing_if = "Option::is_none")]
+    pub new_cluster_enable_elastic_disk: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+    #[serde(rename = "policyId", default, skip_serializing_if = "Option::is_none")]
+    pub policy_id: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDatabricksDetltaLakeLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDetltaLakeLinkedServiceTypeProperties {
+    pub domain: serde_json::Value,
+    #[serde(rename = "accessToken")]
+    pub access_token: SecretBase,
+    #[serde(rename = "clusterId", default, skip_serializing_if = "Option::is_none")]
+    pub cluster_id: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ResponsysLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "clientId")]
+    pub client_id: serde_json::Value,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DynamicsAxLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxLinkedServiceTypeProperties {
+    pub url: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    pub tenant: serde_json::Value,
+    #[serde(rename = "aadResourceId")]
+    pub aad_resource_id: serde_json::Value,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: OracleServiceCloudLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudLinkedServiceTypeProperties {
+    pub host: serde_json::Value,
+    pub username: serde_json::Value,
+    pub password: SecretBase,
+    #[serde(rename = "useEncryptedEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub use_encrypted_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "useHostVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_host_verification: Option<serde_json::Value>,
+    #[serde(rename = "usePeerVerification", default, skip_serializing_if = "Option::is_none")]
+    pub use_peer_verification: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GoogleAdWordsLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsLinkedServiceTypeProperties {
+    #[serde(rename = "clientCustomerID")]
+    pub client_customer_id: serde_json::Value,
+    #[serde(rename = "developerToken")]
+    pub developer_token: SecretBase,
+    #[serde(rename = "authenticationType")]
+    pub authentication_type: google_ad_words_linked_service_type_properties::AuthenticationType,
+    #[serde(rename = "refreshToken", default, skip_serializing_if = "Option::is_none")]
+    pub refresh_token: Option<SecretBase>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub email: Option<serde_json::Value>,
+    #[serde(rename = "keyFilePath", default, skip_serializing_if = "Option::is_none")]
+    pub key_file_path: Option<serde_json::Value>,
+    #[serde(rename = "trustedCertPath", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_cert_path: Option<serde_json::Value>,
+    #[serde(rename = "useSystemTrustStore", default, skip_serializing_if = "Option::is_none")]
+    pub use_system_trust_store: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+pub mod google_ad_words_linked_service_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum AuthenticationType {
+        ServiceAuthentication,
+        UserAuthentication,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SapTableLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableLinkedServiceTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub server: Option<serde_json::Value>,
+    #[serde(rename = "systemNumber", default, skip_serializing_if = "Option::is_none")]
+    pub system_number: Option<serde_json::Value>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<serde_json::Value>,
+    #[serde(rename = "systemId", default, skip_serializing_if = "Option::is_none")]
+    pub system_id: Option<serde_json::Value>,
+    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
+    pub user_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(rename = "messageServer", default, skip_serializing_if = "Option::is_none")]
+    pub message_server: Option<serde_json::Value>,
+    #[serde(rename = "messageServerService", default, skip_serializing_if = "Option::is_none")]
+    pub message_server_service: Option<serde_json::Value>,
+    #[serde(rename = "sncMode", default, skip_serializing_if = "Option::is_none")]
+    pub snc_mode: Option<serde_json::Value>,
+    #[serde(rename = "sncMyName", default, skip_serializing_if = "Option::is_none")]
+    pub snc_my_name: Option<serde_json::Value>,
+    #[serde(rename = "sncPartnerName", default, skip_serializing_if = "Option::is_none")]
+    pub snc_partner_name: Option<serde_json::Value>,
+    #[serde(rename = "sncLibraryPath", default, skip_serializing_if = "Option::is_none")]
+    pub snc_library_path: Option<serde_json::Value>,
+    #[serde(rename = "sncQop", default, skip_serializing_if = "Option::is_none")]
+    pub snc_qop: Option<serde_json::Value>,
+    #[serde(rename = "logonGroup", default, skip_serializing_if = "Option::is_none")]
+    pub logon_group: Option<serde_json::Value>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerLinkedServiceTypeProperties {
+    pub endpoint: serde_json::Value,
+    #[serde(rename = "servicePrincipalId", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_id: Option<serde_json::Value>,
+    #[serde(rename = "servicePrincipalKey", default, skip_serializing_if = "Option::is_none")]
+    pub service_principal_key: Option<SecretBase>,
+    pub database: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tenant: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFunctionLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionLinkedServiceTypeProperties {
+    #[serde(rename = "functionAppUrl")]
+    pub function_app_url: serde_json::Value,
+    #[serde(rename = "functionKey", default, skip_serializing_if = "Option::is_none")]
+    pub function_key: Option<SecretBase>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SnowflakeLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeLinkedServiceTypeProperties {
+    #[serde(rename = "connectionString")]
+    pub connection_string: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<AzureKeyVaultSecretReference>,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListLinkedService {
+    #[serde(flatten)]
+    pub linked_service: LinkedService,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SharePointOnlineListLinkedServiceTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListLinkedServiceTypeProperties {
+    #[serde(rename = "siteUrl")]
+    pub site_url: serde_json::Value,
+    #[serde(rename = "tenantId")]
+    pub tenant_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalId")]
+    pub service_principal_id: serde_json::Value,
+    #[serde(rename = "servicePrincipalKey")]
+    pub service_principal_key: SecretBase,
+    #[serde(rename = "encryptedCredential", default, skip_serializing_if = "Option::is_none")]
+    pub encrypted_credential: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubAccessTokenRequest {
+    #[serde(rename = "gitHubClientId")]
+    pub git_hub_client_id: String,
+    #[serde(rename = "gitHubAccessCode")]
+    pub git_hub_access_code: String,
+    #[serde(rename = "gitHubAccessTokenBaseUrl")]
+    pub git_hub_access_token_base_url: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubAccessTokenResponse {
+    #[serde(rename = "gitHubAccessToken", default, skip_serializing_if = "Option::is_none")]
+    pub git_hub_access_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OperationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<CloudErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryListResponse {
+    pub value: Vec<LibraryResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResourceInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "recordId", default, skip_serializing_if = "Option::is_none")]
+    pub record_id: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub created: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub changed: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "operationId", default, skip_serializing_if = "Option::is_none")]
+    pub operation_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: LibraryResourceProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryResourceProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "containerName", default, skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+    #[serde(rename = "uploadedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub uploaded_timestamp: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<String>,
+    #[serde(rename = "creatorId", default, skip_serializing_if = "Option::is_none")]
+    pub creator_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookListResponse {
+    pub value: Vec<NotebookResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    pub properties: Notebook,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Notebook {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "bigDataPool", default, skip_serializing_if = "Option::is_none")]
+    pub big_data_pool: Option<BigDataPoolReference>,
+    #[serde(rename = "sessionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub session_properties: Option<NotebookSessionProperties>,
+    pub metadata: NotebookMetadata,
+    pub nbformat: i64,
+    pub nbformat_minor: i64,
+    pub cells: Vec<NotebookCell>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<notebook::Folder>,
+}
+pub mod notebook {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolReference {
+    #[serde(rename = "type")]
+    pub type_: big_data_pool_reference::Type,
+    #[serde(rename = "referenceName")]
+    pub reference_name: String,
+}
+pub mod big_data_pool_reference {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        BigDataPoolReference,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookMetadata {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kernelspec: Option<NotebookKernelSpec>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language_info: Option<NotebookLanguageInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookKernelSpec {
+    pub name: String,
+    pub display_name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookLanguageInfo {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub codemirror_mode: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookCell {
+    pub cell_type: String,
+    pub metadata: serde_json::Value,
+    pub source: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub attachments: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<NotebookCellOutputItem>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookSessionProperties {
+    #[serde(rename = "driverMemory")]
+    pub driver_memory: String,
+    #[serde(rename = "driverCores")]
+    pub driver_cores: i64,
+    #[serde(rename = "executorMemory")]
+    pub executor_memory: String,
+    #[serde(rename = "executorCores")]
+    pub executor_cores: i64,
+    #[serde(rename = "numExecutors")]
+    pub num_executors: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NotebookCellOutputItem {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub execution_count: Option<i64>,
+    pub output_type: notebook_cell_output_item::OutputType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub text: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+}
+pub mod notebook_cell_output_item {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum OutputType {
+        #[serde(rename = "execute_result")]
+        ExecuteResult,
+        #[serde(rename = "display_data")]
+        DisplayData,
+        #[serde(rename = "stream")]
+        Stream,
+        #[serde(rename = "error")]
+        Error,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineListResponse {
+    pub value: Vec<PipelineResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Pipeline,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CreateRunResponse {
+    #[serde(rename = "runId")]
+    pub run_id: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRunsQueryResponse {
+    pub value: Vec<PipelineRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRun {
+    #[serde(rename = "runId", default, skip_serializing_if = "Option::is_none")]
+    pub run_id: Option<String>,
+    #[serde(rename = "runGroupId", default, skip_serializing_if = "Option::is_none")]
+    pub run_group_id: Option<String>,
+    #[serde(rename = "isLatest", default, skip_serializing_if = "Option::is_none")]
+    pub is_latest: Option<bool>,
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<serde_json::Value>,
+    #[serde(rename = "invokedBy", default, skip_serializing_if = "Option::is_none")]
+    pub invoked_by: Option<PipelineRunInvokedBy>,
+    #[serde(rename = "lastUpdated", default, skip_serializing_if = "Option::is_none")]
+    pub last_updated: Option<String>,
+    #[serde(rename = "runStart", default, skip_serializing_if = "Option::is_none")]
+    pub run_start: Option<String>,
+    #[serde(rename = "runEnd", default, skip_serializing_if = "Option::is_none")]
+    pub run_end: Option<String>,
+    #[serde(rename = "durationInMs", default, skip_serializing_if = "Option::is_none")]
+    pub duration_in_ms: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineRunInvokedBy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(rename = "invokedByType", default, skip_serializing_if = "Option::is_none")]
+    pub invoked_by_type: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityRunsQueryResponse {
+    pub value: Vec<ActivityRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityRun {
+    #[serde(rename = "pipelineName", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_name: Option<String>,
+    #[serde(rename = "pipelineRunId", default, skip_serializing_if = "Option::is_none")]
+    pub pipeline_run_id: Option<String>,
+    #[serde(rename = "activityName", default, skip_serializing_if = "Option::is_none")]
+    pub activity_name: Option<String>,
+    #[serde(rename = "activityType", default, skip_serializing_if = "Option::is_none")]
+    pub activity_type: Option<String>,
+    #[serde(rename = "activityRunId", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_id: Option<String>,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "activityRunStart", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_start: Option<String>,
+    #[serde(rename = "activityRunEnd", default, skip_serializing_if = "Option::is_none")]
+    pub activity_run_end: Option<String>,
+    #[serde(rename = "durationInMs", default, skip_serializing_if = "Option::is_none")]
+    pub duration_in_ms: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub input: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Pipeline {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub activities: Vec<Activity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub variables: Option<VariableDefinitionSpecification>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub concurrency: Option<i64>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub annotations: Vec<serde_json::Value>,
+    #[serde(rename = "runDimensions", default, skip_serializing_if = "Option::is_none")]
+    pub run_dimensions: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<pipeline::Folder>,
+}
+pub mod pipeline {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Activity {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "dependsOn", default, skip_serializing_if = "Vec::is_empty")]
+    pub depends_on: Vec<ActivityDependency>,
+    #[serde(rename = "userProperties", default, skip_serializing_if = "Vec::is_empty")]
+    pub user_properties: Vec<UserProperty>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UserProperty {
+    pub name: String,
+    pub value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityDependency {
+    pub activity: String,
+    #[serde(rename = "dependencyConditions")]
+    pub dependency_conditions: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ControlActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutionActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+    #[serde(rename = "linkedServiceName", default, skip_serializing_if = "Option::is_none")]
+    pub linked_service_name: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub policy: Option<ActivityPolicy>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ActivityPolicy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub retry: Option<serde_json::Value>,
+    #[serde(rename = "retryIntervalInSeconds", default, skip_serializing_if = "Option::is_none")]
+    pub retry_interval_in_seconds: Option<i64>,
+    #[serde(rename = "secureInput", default, skip_serializing_if = "Option::is_none")]
+    pub secure_input: Option<bool>,
+    #[serde(rename = "secureOutput", default, skip_serializing_if = "Option::is_none")]
+    pub secure_output: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoreReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "listAfter", default, skip_serializing_if = "Option::is_none")]
+    pub list_after: Option<serde_json::Value>,
+    #[serde(rename = "listBefore", default, skip_serializing_if = "Option::is_none")]
+    pub list_before: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonS3ReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(rename = "fileFilter", default, skip_serializing_if = "Option::is_none")]
+    pub file_filter: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "operationTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub operation_timeout: Option<serde_json::Value>,
+    #[serde(rename = "useTempFileRename", default, skip_serializing_if = "Option::is_none")]
+    pub use_temp_file_rename: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleCloudStorageReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prefix: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FtpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "useBinaryTransfer", default, skip_serializing_if = "Option::is_none")]
+    pub use_binary_transfer: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SftpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "requestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsReadSettings {
+    #[serde(flatten)]
+    pub store_read_settings: StoreReadSettings,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFolderPath", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_folder_path: Option<serde_json::Value>,
+    #[serde(rename = "wildcardFileName", default, skip_serializing_if = "Option::is_none")]
+    pub wildcard_file_name: Option<serde_json::Value>,
+    #[serde(rename = "fileListPath", default, skip_serializing_if = "Option::is_none")]
+    pub file_list_path: Option<serde_json::Value>,
+    #[serde(rename = "enablePartitionDiscovery", default, skip_serializing_if = "Option::is_none")]
+    pub enable_partition_discovery: Option<bool>,
+    #[serde(rename = "partitionRootPath", default, skip_serializing_if = "Option::is_none")]
+    pub partition_root_path: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeStart", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_start: Option<serde_json::Value>,
+    #[serde(rename = "modifiedDatetimeEnd", default, skip_serializing_if = "Option::is_none")]
+    pub modified_datetime_end: Option<serde_json::Value>,
+    #[serde(rename = "distcpSettings", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_settings: Option<DistcpSettings>,
+    #[serde(rename = "deleteFilesAfterCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub delete_files_after_completion: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoreWriteSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobStorageWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "blockSizeInMB", default, skip_serializing_if = "Option::is_none")]
+    pub block_size_in_mb: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "blockSizeInMB", default, skip_serializing_if = "Option::is_none")]
+    pub block_size_in_mb: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+    #[serde(rename = "expiryDateTime", default, skip_serializing_if = "Option::is_none")]
+    pub expiry_date_time: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileServerWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFileStorageWriteSettings {
+    #[serde(flatten)]
+    pub store_write_settings: StoreWriteSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FormatReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CompressionReadSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZipDeflateReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveZipFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_zip_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TarReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveCompressionFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_compression_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TarGZipReadSettings {
+    #[serde(flatten)]
+    pub compression_read_settings: CompressionReadSettings,
+    #[serde(rename = "preserveCompressionFileNameAsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub preserve_compression_file_name_as_folder: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "skipLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_line_count: Option<serde_json::Value>,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+    #[serde(rename = "validationMode", default, skip_serializing_if = "Option::is_none")]
+    pub validation_mode: Option<serde_json::Value>,
+    #[serde(rename = "detectDataType", default, skip_serializing_if = "Option::is_none")]
+    pub detect_data_type: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub namespaces: Option<serde_json::Value>,
+    #[serde(rename = "namespacePrefixes", default, skip_serializing_if = "Option::is_none")]
+    pub namespace_prefixes: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinaryReadSettings {
+    #[serde(flatten)]
+    pub format_read_settings: FormatReadSettings,
+    #[serde(rename = "compressionProperties", default, skip_serializing_if = "Option::is_none")]
+    pub compression_properties: Option<CompressionReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FormatWriteSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "recordName", default, skip_serializing_if = "Option::is_none")]
+    pub record_name: Option<String>,
+    #[serde(rename = "recordNamespace", default, skip_serializing_if = "Option::is_none")]
+    pub record_namespace: Option<String>,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "quoteAllText", default, skip_serializing_if = "Option::is_none")]
+    pub quote_all_text: Option<serde_json::Value>,
+    #[serde(rename = "fileExtension")]
+    pub file_extension: serde_json::Value,
+    #[serde(rename = "maxRowsPerFile", default, skip_serializing_if = "Option::is_none")]
+    pub max_rows_per_file: Option<serde_json::Value>,
+    #[serde(rename = "fileNamePrefix", default, skip_serializing_if = "Option::is_none")]
+    pub file_name_prefix: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonWriteSettings {
+    #[serde(flatten)]
+    pub format_write_settings: FormatWriteSettings,
+    #[serde(rename = "filePattern", default, skip_serializing_if = "Option::is_none")]
+    pub file_pattern: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum JsonWriteFilePattern {
+    #[serde(rename = "setOfObjects")]
+    SetOfObjects,
+    #[serde(rename = "arrayOfObjects")]
+    ArrayOfObjects,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExcelSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<DelimitedTextReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<JsonReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XmlSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<XmlReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DelimitedTextSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<DelimitedTextWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JsonSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<JsonWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OrcSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<OrcWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CopyActivityTypeProperties,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub inputs: Vec<DatasetReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub outputs: Vec<DatasetReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivityTypeProperties {
+    pub source: CopySource,
+    pub sink: CopySink,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub translator: Option<serde_json::Value>,
+    #[serde(rename = "enableStaging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_staging: Option<serde_json::Value>,
+    #[serde(rename = "stagingSettings", default, skip_serializing_if = "Option::is_none")]
+    pub staging_settings: Option<StagingSettings>,
+    #[serde(rename = "parallelCopies", default, skip_serializing_if = "Option::is_none")]
+    pub parallel_copies: Option<serde_json::Value>,
+    #[serde(rename = "dataIntegrationUnits", default, skip_serializing_if = "Option::is_none")]
+    pub data_integration_units: Option<serde_json::Value>,
+    #[serde(rename = "enableSkipIncompatibleRow", default, skip_serializing_if = "Option::is_none")]
+    pub enable_skip_incompatible_row: Option<serde_json::Value>,
+    #[serde(rename = "redirectIncompatibleRowSettings", default, skip_serializing_if = "Option::is_none")]
+    pub redirect_incompatible_row_settings: Option<RedirectIncompatibleRowSettings>,
+    #[serde(rename = "logStorageSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_storage_settings: Option<LogStorageSettings>,
+    #[serde(rename = "logSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_settings: Option<LogSettings>,
+    #[serde(rename = "preserveRules", default, skip_serializing_if = "Vec::is_empty")]
+    pub preserve_rules: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub preserve: Vec<serde_json::Value>,
+    #[serde(rename = "validateDataConsistency", default, skip_serializing_if = "Option::is_none")]
+    pub validate_data_consistency: Option<serde_json::Value>,
+    #[serde(rename = "skipErrorFile", default, skip_serializing_if = "Option::is_none")]
+    pub skip_error_file: Option<SkipErrorFile>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopySource {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "sourceRetryCount", default, skip_serializing_if = "Option::is_none")]
+    pub source_retry_count: Option<serde_json::Value>,
+    #[serde(rename = "sourceRetryWait", default, skip_serializing_if = "Option::is_none")]
+    pub source_retry_wait: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinarySource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<BinaryReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TabularSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "azureTableSourceQuery", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_source_query: Option<serde_json::Value>,
+    #[serde(rename = "azureTableSourceIgnoreTableNotFound", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_source_ignore_table_not_found: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipHeaderLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_header_line_count: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "pageSize", default, skip_serializing_if = "Option::is_none")]
+    pub page_size: Option<serde_json::Value>,
+    #[serde(rename = "preferredRegions", default, skip_serializing_if = "Option::is_none")]
+    pub preferred_regions: Option<serde_json::Value>,
+    #[serde(rename = "detectDatetime", default, skip_serializing_if = "Option::is_none")]
+    pub detect_datetime: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RelationalSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Db2Source {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MySqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PostgreSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SybaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapBwSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ODataSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "readBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub read_behavior: Option<salesforce_source::ReadBehavior>,
+}
+pub mod salesforce_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ReadBehavior {
+        Query,
+        QueryAll,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "readBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub read_behavior: Option<salesforce_service_cloud_source::ReadBehavior>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+pub mod salesforce_service_cloud_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ReadBehavior {
+        Query,
+        QueryAll,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapEccSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "packetSize", default, skip_serializing_if = "Option::is_none")]
+    pub packet_size: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<sap_hana_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SapHanaPartitionSettings>,
+}
+pub mod sap_hana_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PhysicalPartitionsOfTable,
+        SapHanaDynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapHanaPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapOpenHubSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "excludeLastRequest", default, skip_serializing_if = "Option::is_none")]
+    pub exclude_last_request: Option<serde_json::Value>,
+    #[serde(rename = "baseRequestId", default, skip_serializing_if = "Option::is_none")]
+    pub base_request_id: Option<serde_json::Value>,
+    #[serde(rename = "customRfcReadTableFunctionModule", default, skip_serializing_if = "Option::is_none")]
+    pub custom_rfc_read_table_function_module: Option<serde_json::Value>,
+    #[serde(rename = "sapDataColumnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub sap_data_column_delimiter: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTableSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "rowCount", default, skip_serializing_if = "Option::is_none")]
+    pub row_count: Option<serde_json::Value>,
+    #[serde(rename = "rowSkips", default, skip_serializing_if = "Option::is_none")]
+    pub row_skips: Option<serde_json::Value>,
+    #[serde(rename = "rfcTableFields", default, skip_serializing_if = "Option::is_none")]
+    pub rfc_table_fields: Option<serde_json::Value>,
+    #[serde(rename = "rfcTableOptions", default, skip_serializing_if = "Option::is_none")]
+    pub rfc_table_options: Option<serde_json::Value>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "customRfcReadTableFunctionModule", default, skip_serializing_if = "Option::is_none")]
+    pub custom_rfc_read_table_function_module: Option<serde_json::Value>,
+    #[serde(rename = "sapDataColumnDelimiter", default, skip_serializing_if = "Option::is_none")]
+    pub sap_data_column_delimiter: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<sap_table_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SapTablePartitionSettings>,
+}
+pub mod sap_table_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PartitionOnInt,
+        PartitionOnCalendarYear,
+        PartitionOnCalendarMonth,
+        PartitionOnCalendarDate,
+        PartitionOnTime,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapTablePartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+    #[serde(rename = "maxPartitionsNumber", default, skip_serializing_if = "Option::is_none")]
+    pub max_partitions_number: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "requestInterval", default, skip_serializing_if = "Option::is_none")]
+    pub request_interval: Option<serde_json::Value>,
+    #[serde(rename = "httpCompressionType", default, skip_serializing_if = "Option::is_none")]
+    pub http_compression_type: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RestSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "requestMethod", default, skip_serializing_if = "Option::is_none")]
+    pub request_method: Option<serde_json::Value>,
+    #[serde(rename = "requestBody", default, skip_serializing_if = "Option::is_none")]
+    pub request_body: Option<serde_json::Value>,
+    #[serde(rename = "additionalHeaders", default, skip_serializing_if = "Option::is_none")]
+    pub additional_headers: Option<serde_json::Value>,
+    #[serde(rename = "paginationRules", default, skip_serializing_if = "Option::is_none")]
+    pub pagination_rules: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+    #[serde(rename = "requestInterval", default, skip_serializing_if = "Option::is_none")]
+    pub request_interval: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "isolationLevel", default, skip_serializing_if = "Option::is_none")]
+    pub isolation_level: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForSqlServerSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlMiSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "produceAdditionalTypes", default, skip_serializing_if = "Option::is_none")]
+    pub produce_additional_types: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlDwSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(rename = "sqlReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "sqlReaderStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_reader_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<SqlPartitionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSystemSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdfsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "distcpSettings", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_settings: Option<DistcpSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DistcpSettings {
+    #[serde(rename = "resourceManagerEndpoint")]
+    pub resource_manager_endpoint: serde_json::Value,
+    #[serde(rename = "tempScriptPath")]
+    pub temp_script_path: serde_json::Value,
+    #[serde(rename = "distcpOptions", default, skip_serializing_if = "Option::is_none")]
+    pub distcp_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    pub query: serde_json::Value,
+    #[serde(rename = "noTruncation", default, skip_serializing_if = "Option::is_none")]
+    pub no_truncation: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "oracleReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub oracle_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<oracle_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<OraclePartitionSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+pub mod oracle_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        PhysicalPartitionsOfTable,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OraclePartitionSettings {
+    #[serde(rename = "partitionNames", default, skip_serializing_if = "Option::is_none")]
+    pub partition_names: Option<serde_json::Value>,
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOracleSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "oracleReaderQuery", default, skip_serializing_if = "Option::is_none")]
+    pub oracle_reader_query: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<serde_json::Value>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<AmazonRdsForOraclePartitionSettings>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AmazonRdsForOraclePartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRdsForOraclePartitionSettings {
+    #[serde(rename = "partitionNames", default, skip_serializing_if = "Option::is_none")]
+    pub partition_names: Option<serde_json::Value>,
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<teradata_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<TeradataPartitionSettings>,
+}
+pub mod teradata_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        Hash,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TeradataPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CassandraSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "consistencyLevel", default, skip_serializing_if = "Option::is_none")]
+    pub consistency_level: Option<cassandra_source::ConsistencyLevel>,
+}
+pub mod cassandra_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ConsistencyLevel {
+        #[serde(rename = "ALL")]
+        All,
+        #[serde(rename = "EACH_QUORUM")]
+        EachQuorum,
+        #[serde(rename = "QUORUM")]
+        Quorum,
+        #[serde(rename = "LOCAL_QUORUM")]
+        LocalQuorum,
+        #[serde(rename = "ONE")]
+        One,
+        #[serde(rename = "TWO")]
+        Two,
+        #[serde(rename = "THREE")]
+        Three,
+        #[serde(rename = "LOCAL_ONE")]
+        LocalOne,
+        #[serde(rename = "SERIAL")]
+        Serial,
+        #[serde(rename = "LOCAL_SERIAL")]
+        LocalSerial,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbAtlasSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbV2Source {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<serde_json::Value>,
+    #[serde(rename = "cursorMethods", default, skip_serializing_if = "Option::is_none")]
+    pub cursor_methods: Option<MongoDbCursorMethodsProperties>,
+    #[serde(rename = "batchSize", default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<serde_json::Value>,
+    #[serde(rename = "additionalColumns", default, skip_serializing_if = "Option::is_none")]
+    pub additional_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MongoDbCursorMethodsProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub project: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sort: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub skip: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Office365Source {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "allowedGroups", default, skip_serializing_if = "Option::is_none")]
+    pub allowed_groups: Option<serde_json::Value>,
+    #[serde(rename = "userScopeFilterUri", default, skip_serializing_if = "Option::is_none")]
+    pub user_scope_filter_uri: Option<serde_json::Value>,
+    #[serde(rename = "dateFilterColumn", default, skip_serializing_if = "Option::is_none")]
+    pub date_filter_column: Option<serde_json::Value>,
+    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
+    pub start_time: Option<serde_json::Value>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<serde_json::Value>,
+    #[serde(rename = "outputColumns", default, skip_serializing_if = "Option::is_none")]
+    pub output_columns: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "treatEmptyAsNull", default, skip_serializing_if = "Option::is_none")]
+    pub treat_empty_as_null: Option<serde_json::Value>,
+    #[serde(rename = "skipHeaderLineCount", default, skip_serializing_if = "Option::is_none")]
+    pub skip_header_line_count: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonMwsSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzurePostgreSqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMySqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ConcurSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CouchbaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DrillSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EloquaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleBigQuerySource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GreenplumSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HBaseSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HiveSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HubspotSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImpalaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct JiraSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MagentoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MariaDbSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMariaDbSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MarketoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PaypalSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PhoenixSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrestoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QuickBooksSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ServiceNowSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ShopifySource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SquareSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct XeroSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ZohoSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "partitionOption", default, skip_serializing_if = "Option::is_none")]
+    pub partition_option: Option<netezza_source::PartitionOption>,
+    #[serde(rename = "partitionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub partition_settings: Option<NetezzaPartitionSettings>,
+}
+pub mod netezza_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PartitionOption {
+        None,
+        DataSlice,
+        DynamicRange,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NetezzaPartitionSettings {
+    #[serde(rename = "partitionColumnName", default, skip_serializing_if = "Option::is_none")]
+    pub partition_column_name: Option<serde_json::Value>,
+    #[serde(rename = "partitionUpperBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_upper_bound: Option<serde_json::Value>,
+    #[serde(rename = "partitionLowerBound", default, skip_serializing_if = "Option::is_none")]
+    pub partition_lower_bound: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VerticaSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceMarketingCloudSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ResponsysSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsAxSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleServiceCloudSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GoogleAdWordsSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AmazonRedshiftSource {
+    #[serde(flatten)]
+    pub tabular_source: TabularSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "redshiftUnloadSettings", default, skip_serializing_if = "Option::is_none")]
+    pub redshift_unload_settings: Option<RedshiftUnloadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedshiftUnloadSettings {
+    #[serde(rename = "s3LinkedServiceName")]
+    pub s3_linked_service_name: LinkedServiceReference,
+    #[serde(rename = "bucketName")]
+    pub bucket_name: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "exportSettings", default, skip_serializing_if = "Option::is_none")]
+    pub export_settings: Option<SnowflakeExportCopyCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExportSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeExportCopyCommand {
+    #[serde(flatten)]
+    pub export_settings: ExportSettings,
+    #[serde(rename = "additionalCopyOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_copy_options: Option<serde_json::Value>,
+    #[serde(rename = "additionalFormatOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_format_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "exportSettings", default, skip_serializing_if = "Option::is_none")]
+    pub export_settings: Option<AzureDatabricksDeltaLakeExportCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeExportCommand {
+    #[serde(flatten)]
+    pub export_settings: ExportSettings,
+    #[serde(rename = "dateFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_format: Option<serde_json::Value>,
+    #[serde(rename = "timestampFormat", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_format: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "importSettings", default, skip_serializing_if = "Option::is_none")]
+    pub import_settings: Option<AzureDatabricksDeltaLakeImportCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDatabricksDeltaLakeImportCommand {
+    #[serde(flatten)]
+    pub import_settings: ImportSettings,
+    #[serde(rename = "dateFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_format: Option<serde_json::Value>,
+    #[serde(rename = "timestampFormat", default, skip_serializing_if = "Option::is_none")]
+    pub timestamp_format: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StoredProcedureParameter {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<StoredProcedureParameterType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum StoredProcedureParameterType {
+    String,
+    Int,
+    Int64,
+    Decimal,
+    Guid,
+    Boolean,
+    Date,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopySink {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(rename = "writeBatchSize", default, skip_serializing_if = "Option::is_none")]
+    pub write_batch_size: Option<serde_json::Value>,
+    #[serde(rename = "writeBatchTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub write_batch_timeout: Option<serde_json::Value>,
+    #[serde(rename = "sinkRetryCount", default, skip_serializing_if = "Option::is_none")]
+    pub sink_retry_count: Option<serde_json::Value>,
+    #[serde(rename = "sinkRetryWait", default, skip_serializing_if = "Option::is_none")]
+    pub sink_retry_wait: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SapCloudForCustomerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<sap_cloud_for_customer_sink::WriteBehavior>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+pub mod sap_cloud_for_customer_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Update,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureQueueSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum CopyBehaviorType {
+    PreserveHierarchy,
+    FlattenHierarchy,
+    MergeFiles,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureTableSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "azureTableDefaultPartitionKeyValue", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_default_partition_key_value: Option<serde_json::Value>,
+    #[serde(rename = "azureTablePartitionKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_partition_key_name: Option<serde_json::Value>,
+    #[serde(rename = "azureTableRowKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_row_key_name: Option<serde_json::Value>,
+    #[serde(rename = "azureTableInsertType", default, skip_serializing_if = "Option::is_none")]
+    pub azure_table_insert_type: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvroSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<AvroWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParquetSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<ParquetWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BinarySink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreWriteSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlobSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "blobWriterOverwriteFiles", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_overwrite_files: Option<serde_json::Value>,
+    #[serde(rename = "blobWriterDateTimeFormat", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_date_time_format: Option<serde_json::Value>,
+    #[serde(rename = "blobWriterAddHeader", default, skip_serializing_if = "Option::is_none")]
+    pub blob_writer_add_header: Option<serde_json::Value>,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSystemSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DocumentDbCollectionSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "nestingSeparator", default, skip_serializing_if = "Option::is_none")]
+    pub nesting_separator: Option<serde_json::Value>,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbSqlApiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSqlSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlMiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "sqlWriterStoredProcedureName", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_stored_procedure_name: Option<serde_json::Value>,
+    #[serde(rename = "sqlWriterTableType", default, skip_serializing_if = "Option::is_none")]
+    pub sql_writer_table_type: Option<serde_json::Value>,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+    #[serde(rename = "storedProcedureTableTypeParameterName", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_table_type_parameter_name: Option<serde_json::Value>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlDwSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "allowPolyBase", default, skip_serializing_if = "Option::is_none")]
+    pub allow_poly_base: Option<serde_json::Value>,
+    #[serde(rename = "polyBaseSettings", default, skip_serializing_if = "Option::is_none")]
+    pub poly_base_settings: Option<PolybaseSettings>,
+    #[serde(rename = "allowCopyCommand", default, skip_serializing_if = "Option::is_none")]
+    pub allow_copy_command: Option<serde_json::Value>,
+    #[serde(rename = "copyCommandSettings", default, skip_serializing_if = "Option::is_none")]
+    pub copy_command_settings: Option<DwCopyCommandSettings>,
+    #[serde(rename = "tableOption", default, skip_serializing_if = "Option::is_none")]
+    pub table_option: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PolybaseSettings {
+    #[serde(rename = "rejectType", default, skip_serializing_if = "Option::is_none")]
+    pub reject_type: Option<PolybaseSettingsRejectType>,
+    #[serde(rename = "rejectValue", default, skip_serializing_if = "Option::is_none")]
+    pub reject_value: Option<serde_json::Value>,
+    #[serde(rename = "rejectSampleValue", default, skip_serializing_if = "Option::is_none")]
+    pub reject_sample_value: Option<serde_json::Value>,
+    #[serde(rename = "useTypeDefault", default, skip_serializing_if = "Option::is_none")]
+    pub use_type_default: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum PolybaseSettingsRejectType {
+    #[serde(rename = "value")]
+    Value,
+    #[serde(rename = "percentage")]
+    Percentage,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DwCopyCommandSettings {
+    #[serde(rename = "defaultValues", default, skip_serializing_if = "Vec::is_empty")]
+    pub default_values: Vec<DwCopyCommandDefaultValue>,
+    #[serde(rename = "additionalOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DwCopyCommandDefaultValue {
+    #[serde(rename = "columnName", default, skip_serializing_if = "Option::is_none")]
+    pub column_name: Option<serde_json::Value>,
+    #[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
+    pub default_value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+    #[serde(rename = "importSettings", default, skip_serializing_if = "Option::is_none")]
+    pub import_settings: Option<SnowflakeImportCopyCommand>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImportSettings {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SnowflakeImportCopyCommand {
+    #[serde(flatten)]
+    pub import_settings: ImportSettings,
+    #[serde(rename = "additionalCopyOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_copy_options: Option<serde_json::Value>,
+    #[serde(rename = "additionalFormatOptions", default, skip_serializing_if = "Option::is_none")]
+    pub additional_format_options: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogStorageSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
+    pub log_level: Option<serde_json::Value>,
+    #[serde(rename = "enableReliableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_reliable_logging: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogSettings {
+    #[serde(rename = "enableCopyActivityLog", default, skip_serializing_if = "Option::is_none")]
+    pub enable_copy_activity_log: Option<serde_json::Value>,
+    #[serde(rename = "copyActivityLogSettings", default, skip_serializing_if = "Option::is_none")]
+    pub copy_activity_log_settings: Option<CopyActivityLogSettings>,
+    #[serde(rename = "logLocationSettings")]
+    pub log_location_settings: LogLocationSettings,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogLocationSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyActivityLogSettings {
+    #[serde(rename = "logLevel", default, skip_serializing_if = "Option::is_none")]
+    pub log_level: Option<serde_json::Value>,
+    #[serde(rename = "enableReliableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_reliable_logging: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StagingSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+    #[serde(rename = "enableCompression", default, skip_serializing_if = "Option::is_none")]
+    pub enable_compression: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RedirectIncompatibleRowSettings {
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SkipErrorFile {
+    #[serde(rename = "fileMissing", default, skip_serializing_if = "Option::is_none")]
+    pub file_missing: Option<serde_json::Value>,
+    #[serde(rename = "dataInconsistency", default, skip_serializing_if = "Option::is_none")]
+    pub data_inconsistency: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdditionalColumns {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OracleSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataLakeStoreSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+    #[serde(rename = "enableAdlsSingleFileParallel", default, skip_serializing_if = "Option::is_none")]
+    pub enable_adls_single_file_parallel: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureBlobFsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "copyBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub copy_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureSearchIndexSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<azure_search_index_sink::WriteBehavior>,
+}
+pub mod azure_search_index_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Merge,
+        Upload,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OdbcSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InformixSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MicrosoftAccessSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "preCopyScript", default, skip_serializing_if = "Option::is_none")]
+    pub pre_copy_script: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum DynamicsSinkWriteBehavior {
+    Upsert,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicsCrmSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CommonDataServiceForAppsSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior")]
+    pub write_behavior: DynamicsSinkWriteBehavior,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+    #[serde(rename = "alternateKeyName", default, skip_serializing_if = "Option::is_none")]
+    pub alternate_key_name: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "ingestionMappingName", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_mapping_name: Option<serde_json::Value>,
+    #[serde(rename = "ingestionMappingAsJson", default, skip_serializing_if = "Option::is_none")]
+    pub ingestion_mapping_as_json: Option<serde_json::Value>,
+    #[serde(rename = "flushImmediately", default, skip_serializing_if = "Option::is_none")]
+    pub flush_immediately: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<salesforce_sink::WriteBehavior>,
+    #[serde(rename = "externalIdFieldName", default, skip_serializing_if = "Option::is_none")]
+    pub external_id_field_name: Option<serde_json::Value>,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+}
+pub mod salesforce_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Upsert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SalesforceServiceCloudSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<salesforce_service_cloud_sink::WriteBehavior>,
+    #[serde(rename = "externalIdFieldName", default, skip_serializing_if = "Option::is_none")]
+    pub external_id_field_name: Option<serde_json::Value>,
+    #[serde(rename = "ignoreNullValues", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_null_values: Option<serde_json::Value>,
+}
+pub mod salesforce_service_cloud_sink {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum WriteBehavior {
+        Insert,
+        Upsert,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CosmosDbMongoDbApiSink {
+    #[serde(flatten)]
+    pub copy_sink: CopySink,
+    #[serde(rename = "writeBehavior", default, skip_serializing_if = "Option::is_none")]
+    pub write_behavior: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CopyTranslator {
+    #[serde(rename = "type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TabularTranslator {
+    #[serde(flatten)]
+    pub copy_translator: CopyTranslator,
+    #[serde(rename = "columnMappings", default, skip_serializing_if = "Option::is_none")]
+    pub column_mappings: Option<serde_json::Value>,
+    #[serde(rename = "schemaMapping", default, skip_serializing_if = "Option::is_none")]
+    pub schema_mapping: Option<serde_json::Value>,
+    #[serde(rename = "collectionReference", default, skip_serializing_if = "Option::is_none")]
+    pub collection_reference: Option<serde_json::Value>,
+    #[serde(rename = "mapComplexValuesToString", default, skip_serializing_if = "Option::is_none")]
+    pub map_complex_values_to_string: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mappings: Option<serde_json::Value>,
+    #[serde(rename = "typeConversion", default, skip_serializing_if = "Option::is_none")]
+    pub type_conversion: Option<serde_json::Value>,
+    #[serde(rename = "typeConversionSettings", default, skip_serializing_if = "Option::is_none")]
+    pub type_conversion_settings: Option<TypeConversionSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypeConversionSettings {
+    #[serde(rename = "allowDataTruncation", default, skip_serializing_if = "Option::is_none")]
+    pub allow_data_truncation: Option<serde_json::Value>,
+    #[serde(rename = "treatBooleanAsNumber", default, skip_serializing_if = "Option::is_none")]
+    pub treat_boolean_as_number: Option<serde_json::Value>,
+    #[serde(rename = "dateTimeFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_time_format: Option<serde_json::Value>,
+    #[serde(rename = "dateTimeOffsetFormat", default, skip_serializing_if = "Option::is_none")]
+    pub date_time_offset_format: Option<serde_json::Value>,
+    #[serde(rename = "timeSpanFormat", default, skip_serializing_if = "Option::is_none")]
+    pub time_span_format: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub culture: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightHiveActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightHiveActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightHiveActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "scriptPath", default, skip_serializing_if = "Option::is_none")]
+    pub script_path: Option<serde_json::Value>,
+    #[serde(rename = "scriptLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub script_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub variables: Vec<serde_json::Value>,
+    #[serde(rename = "queryTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub query_timeout: Option<i64>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum HdInsightActivityDebugInfoOption {
+    None,
+    Always,
+    Failure,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightPigActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightPigActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightPigActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub arguments: Option<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "scriptPath", default, skip_serializing_if = "Option::is_none")]
+    pub script_path: Option<serde_json::Value>,
+    #[serde(rename = "scriptLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub script_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightMapReduceActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightMapReduceActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightMapReduceActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "className")]
+    pub class_name: serde_json::Value,
+    #[serde(rename = "jarFilePath")]
+    pub jar_file_path: serde_json::Value,
+    #[serde(rename = "jarLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub jar_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "jarLibs", default, skip_serializing_if = "Vec::is_empty")]
+    pub jar_libs: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightStreamingActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightStreamingActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightStreamingActivityTypeProperties {
+    #[serde(rename = "storageLinkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub storage_linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    pub mapper: serde_json::Value,
+    pub reducer: serde_json::Value,
+    pub input: serde_json::Value,
+    pub output: serde_json::Value,
+    #[serde(rename = "filePaths")]
+    pub file_paths: Vec<serde_json::Value>,
+    #[serde(rename = "fileLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub file_linked_service: Option<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub combiner: Option<serde_json::Value>,
+    #[serde(rename = "commandEnvironment", default, skip_serializing_if = "Vec::is_empty")]
+    pub command_environment: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub defines: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightSparkActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: HdInsightSparkActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HdInsightSparkActivityTypeProperties {
+    #[serde(rename = "rootPath")]
+    pub root_path: serde_json::Value,
+    #[serde(rename = "entryFilePath")]
+    pub entry_file_path: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub arguments: Vec<serde_json::Value>,
+    #[serde(rename = "getDebugInfo", default, skip_serializing_if = "Option::is_none")]
+    pub get_debug_info: Option<HdInsightActivityDebugInfoOption>,
+    #[serde(rename = "sparkJobLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub spark_job_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(rename = "proxyUser", default, skip_serializing_if = "Option::is_none")]
+    pub proxy_user: Option<serde_json::Value>,
+    #[serde(rename = "sparkConfig", default, skip_serializing_if = "Option::is_none")]
+    pub spark_config: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteSsisPackageActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecuteSsisPackageActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteSsisPackageActivityTypeProperties {
+    #[serde(rename = "packageLocation")]
+    pub package_location: SsisPackageLocation,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub runtime: Option<serde_json::Value>,
+    #[serde(rename = "loggingLevel", default, skip_serializing_if = "Option::is_none")]
+    pub logging_level: Option<serde_json::Value>,
+    #[serde(rename = "environmentPath", default, skip_serializing_if = "Option::is_none")]
+    pub environment_path: Option<serde_json::Value>,
+    #[serde(rename = "executionCredential", default, skip_serializing_if = "Option::is_none")]
+    pub execution_credential: Option<SsisExecutionCredential>,
+    #[serde(rename = "connectVia")]
+    pub connect_via: IntegrationRuntimeReference,
+    #[serde(rename = "projectParameters", default, skip_serializing_if = "Option::is_none")]
+    pub project_parameters: Option<serde_json::Value>,
+    #[serde(rename = "packageParameters", default, skip_serializing_if = "Option::is_none")]
+    pub package_parameters: Option<serde_json::Value>,
+    #[serde(rename = "projectConnectionManagers", default, skip_serializing_if = "Option::is_none")]
+    pub project_connection_managers: Option<serde_json::Value>,
+    #[serde(rename = "packageConnectionManagers", default, skip_serializing_if = "Option::is_none")]
+    pub package_connection_managers: Option<serde_json::Value>,
+    #[serde(rename = "propertyOverrides", default, skip_serializing_if = "Option::is_none")]
+    pub property_overrides: Option<serde_json::Value>,
+    #[serde(rename = "logLocation", default, skip_serializing_if = "Option::is_none")]
+    pub log_location: Option<SsisLogLocation>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPackageLocation {
+    #[serde(rename = "packagePath", default, skip_serializing_if = "Option::is_none")]
+    pub package_path: Option<serde_json::Value>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<ssis_package_location::Type>,
+    #[serde(rename = "typeProperties", default, skip_serializing_if = "Option::is_none")]
+    pub type_properties: Option<SsisPackageLocationTypeProperties>,
+}
+pub mod ssis_package_location {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "SSISDB")]
+        Ssisdb,
+        File,
+        InlinePackage,
+        PackageStore,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPackageLocationTypeProperties {
+    #[serde(rename = "packagePassword", default, skip_serializing_if = "Option::is_none")]
+    pub package_password: Option<SecretBase>,
+    #[serde(rename = "accessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "configurationPath", default, skip_serializing_if = "Option::is_none")]
+    pub configuration_path: Option<serde_json::Value>,
+    #[serde(rename = "configurationAccessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub configuration_access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(rename = "packageContent", default, skip_serializing_if = "Option::is_none")]
+    pub package_content: Option<serde_json::Value>,
+    #[serde(rename = "packageLastModifiedDate", default, skip_serializing_if = "Option::is_none")]
+    pub package_last_modified_date: Option<String>,
+    #[serde(rename = "childPackages", default, skip_serializing_if = "Vec::is_empty")]
+    pub child_packages: Vec<SsisChildPackage>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisConnectionManager {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisExecutionParameter {
+    pub value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisPropertyOverride {
+    pub value: serde_json::Value,
+    #[serde(rename = "isSensitive", default, skip_serializing_if = "Option::is_none")]
+    pub is_sensitive: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisExecutionCredential {
+    pub domain: serde_json::Value,
+    #[serde(rename = "userName")]
+    pub user_name: serde_json::Value,
+    pub password: SecureString,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisAccessCredential {
+    pub domain: serde_json::Value,
+    #[serde(rename = "userName")]
+    pub user_name: serde_json::Value,
+    pub password: SecretBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisChildPackage {
+    #[serde(rename = "packagePath")]
+    pub package_path: serde_json::Value,
+    #[serde(rename = "packageName", default, skip_serializing_if = "Option::is_none")]
+    pub package_name: Option<String>,
+    #[serde(rename = "packageContent")]
+    pub package_content: serde_json::Value,
+    #[serde(rename = "packageLastModifiedDate", default, skip_serializing_if = "Option::is_none")]
+    pub package_last_modified_date: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisLogLocation {
+    #[serde(rename = "logPath")]
+    pub log_path: serde_json::Value,
+    #[serde(rename = "type")]
+    pub type_: ssis_log_location::Type,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SsisLogLocationTypeProperties,
+}
+pub mod ssis_log_location {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        File,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SsisLogLocationTypeProperties {
+    #[serde(rename = "accessCredential", default, skip_serializing_if = "Option::is_none")]
+    pub access_credential: Option<SsisAccessCredential>,
+    #[serde(rename = "logRefreshInterval", default, skip_serializing_if = "Option::is_none")]
+    pub log_refresh_interval: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: CustomActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivityTypeProperties {
+    pub command: serde_json::Value,
+    #[serde(rename = "resourceLinkedService", default, skip_serializing_if = "Option::is_none")]
+    pub resource_linked_service: Option<LinkedServiceReference>,
+    #[serde(rename = "folderPath", default, skip_serializing_if = "Option::is_none")]
+    pub folder_path: Option<serde_json::Value>,
+    #[serde(rename = "referenceObjects", default, skip_serializing_if = "Option::is_none")]
+    pub reference_objects: Option<CustomActivityReferenceObject>,
+    #[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<serde_json::Value>,
+    #[serde(rename = "retentionTimeInDays", default, skip_serializing_if = "Option::is_none")]
+    pub retention_time_in_days: Option<serde_json::Value>,
+    #[serde(rename = "autoUserSpecification", default, skip_serializing_if = "Option::is_none")]
+    pub auto_user_specification: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomActivityReferenceObject {
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceReference>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerStoredProcedureActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlServerStoredProcedureActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlServerStoredProcedureActivityTypeProperties {
+    #[serde(rename = "storedProcedureName")]
+    pub stored_procedure_name: serde_json::Value,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutePipelineActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecutePipelineActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutePipelineActivityTypeProperties {
+    pub pipeline: PipelineReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+    #[serde(rename = "waitOnCompletion", default, skip_serializing_if = "Option::is_none")]
+    pub wait_on_completion: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DeleteActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DeleteActivityTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<serde_json::Value>,
+    #[serde(rename = "maxConcurrentConnections", default, skip_serializing_if = "Option::is_none")]
+    pub max_concurrent_connections: Option<i64>,
+    #[serde(rename = "enableLogging", default, skip_serializing_if = "Option::is_none")]
+    pub enable_logging: Option<serde_json::Value>,
+    #[serde(rename = "logStorageSettings", default, skip_serializing_if = "Option::is_none")]
+    pub log_storage_settings: Option<LogStorageSettings>,
+    pub dataset: DatasetReference,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCommandActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureDataExplorerCommandActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureDataExplorerCommandActivityTypeProperties {
+    pub command: serde_json::Value,
+    #[serde(rename = "commandTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub command_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LookupActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: LookupActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LookupActivityTypeProperties {
+    pub source: CopySource,
+    pub dataset: DatasetReference,
+    #[serde(rename = "firstRowOnly", default, skip_serializing_if = "Option::is_none")]
+    pub first_row_only: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum WebActivityMethod {
+    #[serde(rename = "GET")]
+    Get,
+    #[serde(rename = "POST")]
+    Post,
+    #[serde(rename = "PUT")]
+    Put,
+    #[serde(rename = "DELETE")]
+    Delete,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivityAuthentication {
+    #[serde(rename = "type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pfx: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub username: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub password: Option<SecretBase>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub resource: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebActivityTypeProperties {
+    pub method: WebActivityMethod,
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<WebActivityAuthentication>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub datasets: Vec<DatasetReference>,
+    #[serde(rename = "linkedServices", default, skip_serializing_if = "Vec::is_empty")]
+    pub linked_services: Vec<LinkedServiceReference>,
+    #[serde(rename = "connectVia", default, skip_serializing_if = "Option::is_none")]
+    pub connect_via: Option<IntegrationRuntimeReference>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetMetadataActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: GetMetadataActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetMetadataActivityTypeProperties {
+    pub dataset: DatasetReference,
+    #[serde(rename = "fieldList", default, skip_serializing_if = "Vec::is_empty")]
+    pub field_list: Vec<serde_json::Value>,
+    #[serde(rename = "storeSettings", default, skip_serializing_if = "Option::is_none")]
+    pub store_settings: Option<StoreReadSettings>,
+    #[serde(rename = "formatSettings", default, skip_serializing_if = "Option::is_none")]
+    pub format_settings: Option<FormatReadSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IfConditionActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: IfConditionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IfConditionActivityTypeProperties {
+    pub expression: Expression,
+    #[serde(rename = "ifTrueActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub if_true_activities: Vec<Activity>,
+    #[serde(rename = "ifFalseActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub if_false_activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SwitchActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchActivityTypeProperties {
+    pub on: Expression,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub cases: Vec<SwitchCase>,
+    #[serde(rename = "defaultActivities", default, skip_serializing_if = "Vec::is_empty")]
+    pub default_activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SwitchCase {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ForEachActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ForEachActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ForEachActivityTypeProperties {
+    #[serde(rename = "isSequential", default, skip_serializing_if = "Option::is_none")]
+    pub is_sequential: Option<bool>,
+    #[serde(rename = "batchCount", default, skip_serializing_if = "Option::is_none")]
+    pub batch_count: Option<i64>,
+    pub items: Expression,
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlBatchExecutionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlBatchExecutionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlBatchExecutionActivityTypeProperties {
+    #[serde(rename = "globalParameters", default, skip_serializing_if = "Option::is_none")]
+    pub global_parameters: Option<serde_json::Value>,
+    #[serde(rename = "webServiceOutputs", default, skip_serializing_if = "Option::is_none")]
+    pub web_service_outputs: Option<serde_json::Value>,
+    #[serde(rename = "webServiceInputs", default, skip_serializing_if = "Option::is_none")]
+    pub web_service_inputs: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlWebServiceFile {
+    #[serde(rename = "filePath")]
+    pub file_path: serde_json::Value,
+    #[serde(rename = "linkedServiceName")]
+    pub linked_service_name: LinkedServiceReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlUpdateResourceActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlUpdateResourceActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlUpdateResourceActivityTypeProperties {
+    #[serde(rename = "trainedModelName")]
+    pub trained_model_name: serde_json::Value,
+    #[serde(rename = "trainedModelLinkedServiceName")]
+    pub trained_model_linked_service_name: LinkedServiceReference,
+    #[serde(rename = "trainedModelFilePath")]
+    pub trained_model_file_path: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlExecutePipelineActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureMlExecutePipelineActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlExecutePipelineActivityTypeProperties {
+    #[serde(rename = "mlPipelineId")]
+    pub ml_pipeline_id: serde_json::Value,
+    #[serde(rename = "experimentName", default, skip_serializing_if = "Option::is_none")]
+    pub experiment_name: Option<serde_json::Value>,
+    #[serde(rename = "mlPipelineParameters", default, skip_serializing_if = "Option::is_none")]
+    pub ml_pipeline_parameters: Option<serde_json::Value>,
+    #[serde(rename = "mlParentRunId", default, skip_serializing_if = "Option::is_none")]
+    pub ml_parent_run_id: Option<serde_json::Value>,
+    #[serde(rename = "continueOnStepFailure", default, skip_serializing_if = "Option::is_none")]
+    pub continue_on_step_failure: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureMlPipelineParameters {}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsUsqlActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DataLakeAnalyticsUsqlActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeAnalyticsUsqlActivityTypeProperties {
+    #[serde(rename = "scriptPath")]
+    pub script_path: serde_json::Value,
+    #[serde(rename = "scriptLinkedService")]
+    pub script_linked_service: LinkedServiceReference,
+    #[serde(rename = "degreeOfParallelism", default, skip_serializing_if = "Option::is_none")]
+    pub degree_of_parallelism: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub priority: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<serde_json::Value>,
+    #[serde(rename = "runtimeVersion", default, skip_serializing_if = "Option::is_none")]
+    pub runtime_version: Option<serde_json::Value>,
+    #[serde(rename = "compilationMode", default, skip_serializing_if = "Option::is_none")]
+    pub compilation_mode: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WaitActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WaitActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WaitActivityTypeProperties {
+    #[serde(rename = "waitTimeInSeconds")]
+    pub wait_time_in_seconds: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UntilActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: UntilActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UntilActivityTypeProperties {
+    pub expression: Expression,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    pub activities: Vec<Activity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ValidationActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ValidationActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ValidationActivityTypeProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sleep: Option<serde_json::Value>,
+    #[serde(rename = "minimumSize", default, skip_serializing_if = "Option::is_none")]
+    pub minimum_size: Option<serde_json::Value>,
+    #[serde(rename = "childItems", default, skip_serializing_if = "Option::is_none")]
+    pub child_items: Option<serde_json::Value>,
+    pub dataset: DatasetReference,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: FilterActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FilterActivityTypeProperties {
+    pub items: Expression,
+    pub condition: Expression,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksNotebookActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksNotebookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksNotebookActivityTypeProperties {
+    #[serde(rename = "notebookPath")]
+    pub notebook_path: serde_json::Value,
+    #[serde(rename = "baseParameters", default, skip_serializing_if = "Option::is_none")]
+    pub base_parameters: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkJarActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksSparkJarActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkJarActivityTypeProperties {
+    #[serde(rename = "mainClassName")]
+    pub main_class_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkPythonActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: DatabricksSparkPythonActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DatabricksSparkPythonActivityTypeProperties {
+    #[serde(rename = "pythonFile")]
+    pub python_file: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub libraries: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetVariableActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SetVariableActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SetVariableActivityTypeProperties {
+    #[serde(rename = "variableName", default, skip_serializing_if = "Option::is_none")]
+    pub variable_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppendVariableActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AppendVariableActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AppendVariableActivityTypeProperties {
+    #[serde(rename = "variableName", default, skip_serializing_if = "Option::is_none")]
+    pub variable_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum AzureFunctionActivityMethod {
+    #[serde(rename = "GET")]
+    Get,
+    #[serde(rename = "POST")]
+    Post,
+    #[serde(rename = "PUT")]
+    Put,
+    #[serde(rename = "DELETE")]
+    Delete,
+    #[serde(rename = "OPTIONS")]
+    Options,
+    #[serde(rename = "HEAD")]
+    Head,
+    #[serde(rename = "TRACE")]
+    Trace,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: AzureFunctionActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureFunctionActivityTypeProperties {
+    pub method: AzureFunctionActivityMethod,
+    #[serde(rename = "functionName")]
+    pub function_name: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebHookActivity {
+    #[serde(flatten)]
+    pub control_activity: ControlActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: WebHookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum WebHookActivityMethod {
+    #[serde(rename = "POST")]
+    Post,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebHookActivityTypeProperties {
+    pub method: WebHookActivityMethod,
+    pub url: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub headers: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub authentication: Option<WebActivityAuthentication>,
+    #[serde(rename = "reportStatusOnCallBack", default, skip_serializing_if = "Option::is_none")]
+    pub report_status_on_call_back: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteDataFlowActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: ExecuteDataFlowActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecuteDataFlowActivityTypeProperties {
+    pub dataflow: DataFlowReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub staging: Option<DataFlowStagingInfo>,
+    #[serde(rename = "integrationRuntime", default, skip_serializing_if = "Option::is_none")]
+    pub integration_runtime: Option<IntegrationRuntimeReference>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<execute_data_flow_activity_type_properties::Compute>,
+    #[serde(rename = "traceLevel", default, skip_serializing_if = "Option::is_none")]
+    pub trace_level: Option<serde_json::Value>,
+    #[serde(rename = "continueOnError", default, skip_serializing_if = "Option::is_none")]
+    pub continue_on_error: Option<serde_json::Value>,
+    #[serde(rename = "runConcurrently", default, skip_serializing_if = "Option::is_none")]
+    pub run_concurrently: Option<serde_json::Value>,
+}
+pub mod execute_data_flow_activity_type_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Compute {
+        #[serde(rename = "computeType", default, skip_serializing_if = "Option::is_none")]
+        pub compute_type: Option<compute::ComputeType>,
+        #[serde(rename = "coreCount", default, skip_serializing_if = "Option::is_none")]
+        pub core_count: Option<i64>,
+    }
+    pub mod compute {
+        use super::*;
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        pub enum ComputeType {
+            General,
+            MemoryOptimized,
+            ComputeOptimized,
+        }
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SharePointOnlineListSource {
+    #[serde(flatten)]
+    pub copy_source: CopySource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<serde_json::Value>,
+    #[serde(rename = "httpRequestTimeout", default, skip_serializing_if = "Option::is_none")]
+    pub http_request_timeout: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SqlPartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SapHanaPartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    SapHanaDynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SapTablePartitionOption {
+    None,
+    PartitionOnInt,
+    PartitionOnCalendarYear,
+    PartitionOnCalendarMonth,
+    PartitionOnCalendarDate,
+    PartitionOnTime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum OraclePartitionOption {
+    None,
+    PhysicalPartitionsOfTable,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TeradataPartitionOption {
+    None,
+    Hash,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum NetezzaPartitionOption {
+    None,
+    DataSlice,
+    DynamicRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SynapseNotebookActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseNotebookActivityTypeProperties {
+    pub notebook: SynapseNotebookReference,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parameters: Option<ParameterValueSpecification>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobDefinitionActivity {
+    #[serde(flatten)]
+    pub execution_activity: ExecutionActivity,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SynapseSparkJobActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SynapseSparkJobActivityTypeProperties {
+    #[serde(rename = "sparkJob")]
+    pub spark_job: SynapseSparkJobReference,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolStoredProcedureActivity {
+    #[serde(flatten)]
+    pub activity: Activity,
+    #[serde(rename = "sqlPool")]
+    pub sql_pool: SqlPoolReference,
+    #[serde(rename = "typeProperties")]
+    pub type_properties: SqlPoolStoredProcedureActivityTypeProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolStoredProcedureActivityTypeProperties {
+    #[serde(rename = "storedProcedureName")]
+    pub stored_procedure_name: serde_json::Value,
+    #[serde(rename = "storedProcedureParameters", default, skip_serializing_if = "Option::is_none")]
+    pub stored_procedure_parameters: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinitionsListResponse {
+    pub value: Vec<SparkJobDefinitionResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinitionResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: SparkJobDefinition,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobDefinition {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "targetBigDataPool")]
+    pub target_big_data_pool: BigDataPoolReference,
+    #[serde(rename = "requiredSparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub required_spark_version: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+    #[serde(rename = "jobProperties")]
+    pub job_properties: SparkJobProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<spark_job_definition::Folder>,
+}
+pub mod spark_job_definition {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    pub file: String,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(rename = "driverMemory")]
+    pub driver_memory: String,
+    #[serde(rename = "driverCores")]
+    pub driver_cores: i64,
+    #[serde(rename = "executorMemory")]
+    pub executor_memory: String,
+    #[serde(rename = "executorCores")]
+    pub executor_cores: i64,
+    #[serde(rename = "numExecutors")]
+    pub num_executors: i64,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptsListResponse {
+    pub value: Vec<SqlScriptResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+    pub properties: SqlScript,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScript {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<sql_script::Type>,
+    pub content: SqlScriptContent,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub folder: Option<sql_script::Folder>,
+}
+pub mod sql_script {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlQuery,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Folder {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptContent {
+    pub query: String,
+    #[serde(rename = "currentConnection", default, skip_serializing_if = "Option::is_none")]
+    pub current_connection: Option<SqlConnection>,
+    #[serde(rename = "resultLimit", default, skip_serializing_if = "Option::is_none")]
+    pub result_limit: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<SqlScriptMetadata>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlScriptMetadata {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub language: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlConnection {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<sql_connection::Type>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "poolName", default, skip_serializing_if = "Option::is_none")]
+    pub pool_name: Option<String>,
+    #[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
+    pub database_name: Option<String>,
+}
+pub mod sql_connection {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        SqlOnDemand,
+        SqlPool,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerListResponse {
+    pub value: Vec<TriggerResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: Trigger,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRunsQueryResponse {
+    pub value: Vec<TriggerRun>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerRun {
+    #[serde(rename = "triggerRunId", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_run_id: Option<String>,
+    #[serde(rename = "triggerName", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_name: Option<String>,
+    #[serde(rename = "triggerType", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_type: Option<String>,
+    #[serde(rename = "triggerRunTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_run_timestamp: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<trigger_run::Status>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<serde_json::Value>,
+    #[serde(rename = "triggeredPipelines", default, skip_serializing_if = "Option::is_none")]
+    pub triggered_pipelines: Option<serde_json::Value>,
+}
+pub mod trigger_run {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Succeeded,
+        Failed,
+        Inprogress,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TriggerSubscriptionOperationStatus {
+    #[serde(rename = "triggerName", default, skip_serializing_if = "Option::is_none")]
+    pub trigger_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<trigger_subscription_operation_status::Status>,
+}
+pub mod trigger_subscription_operation_status {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Status {
+        Enabled,
+        Provisioning,
+        Deprovisioning,
+        Disabled,
+        Unknown,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorResponse>,
+    #[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_info: Vec<ErrorAdditionalInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorAdditionalInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AzureEntityResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub etag: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Resource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceInfoListResult {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<BigDataPoolResourceInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceInfo {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<BigDataPoolResourceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BigDataPoolResourceProperties {
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "autoScale", default, skip_serializing_if = "Option::is_none")]
+    pub auto_scale: Option<AutoScaleProperties>,
+    #[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
+    pub creation_date: Option<String>,
+    #[serde(rename = "autoPause", default, skip_serializing_if = "Option::is_none")]
+    pub auto_pause: Option<AutoPauseProperties>,
+    #[serde(rename = "isComputeIsolationEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub is_compute_isolation_enabled: Option<bool>,
+    #[serde(rename = "sessionLevelPackagesEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub session_level_packages_enabled: Option<bool>,
+    #[serde(rename = "cacheSize", default, skip_serializing_if = "Option::is_none")]
+    pub cache_size: Option<i32>,
+    #[serde(rename = "dynamicExecutorAllocation", default, skip_serializing_if = "Option::is_none")]
+    pub dynamic_executor_allocation: Option<DynamicExecutorAllocation>,
+    #[serde(rename = "sparkEventsFolder", default, skip_serializing_if = "Option::is_none")]
+    pub spark_events_folder: Option<String>,
+    #[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub node_count: Option<i32>,
+    #[serde(rename = "libraryRequirements", default, skip_serializing_if = "Option::is_none")]
+    pub library_requirements: Option<LibraryRequirements>,
+    #[serde(rename = "customLibraries", default, skip_serializing_if = "Vec::is_empty")]
+    pub custom_libraries: Vec<LibraryInfo>,
+    #[serde(rename = "sparkConfigProperties", default, skip_serializing_if = "Option::is_none")]
+    pub spark_config_properties: Option<LibraryRequirements>,
+    #[serde(rename = "sparkVersion", default, skip_serializing_if = "Option::is_none")]
+    pub spark_version: Option<String>,
+    #[serde(rename = "defaultSparkLogFolder", default, skip_serializing_if = "Option::is_none")]
+    pub default_spark_log_folder: Option<String>,
+    #[serde(rename = "nodeSize", default, skip_serializing_if = "Option::is_none")]
+    pub node_size: Option<big_data_pool_resource_properties::NodeSize>,
+    #[serde(rename = "nodeSizeFamily", default, skip_serializing_if = "Option::is_none")]
+    pub node_size_family: Option<big_data_pool_resource_properties::NodeSizeFamily>,
+    #[serde(rename = "lastSucceededTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub last_succeeded_timestamp: Option<String>,
+}
+pub mod big_data_pool_resource_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum NodeSize {
+        None,
+        Small,
+        Medium,
+        Large,
+        XLarge,
+        #[serde(rename = "XXLarge")]
+        XxLarge,
+        #[serde(rename = "XXXLarge")]
+        XxxLarge,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum NodeSizeFamily {
+        None,
+        MemoryOptimized,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AutoScaleProperties {
+    #[serde(rename = "minNodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub min_node_count: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+    #[serde(rename = "maxNodeCount", default, skip_serializing_if = "Option::is_none")]
+    pub max_node_count: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AutoPauseProperties {
+    #[serde(rename = "delayInMinutes", default, skip_serializing_if = "Option::is_none")]
+    pub delay_in_minutes: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DynamicExecutorAllocation {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enabled: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryRequirements {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub content: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filename: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LibraryInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(rename = "containerName", default, skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+    #[serde(rename = "uploadedTimestamp", default, skip_serializing_if = "Option::is_none")]
+    pub uploaded_timestamp: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "provisioningStatus", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_status: Option<String>,
+    #[serde(rename = "creatorId", default, skip_serializing_if = "Option::is_none")]
+    pub creator_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TrackedResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub location: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntime {
+    #[serde(rename = "type")]
+    pub type_: IntegrationRuntimeType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum IntegrationRuntimeType {
+    Managed,
+    SelfHosted,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeListResponse {
+    pub value: Vec<IntegrationRuntimeResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IntegrationRuntimeResource {
+    #[serde(flatten)]
+    pub sub_resource: SubResource,
+    pub properties: IntegrationRuntime,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJob {
+    #[serde(rename = "livyInfo", default, skip_serializing_if = "Option::is_none")]
+    pub livy_info: Option<SparkBatchJobState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "workspaceName", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_name: Option<String>,
+    #[serde(rename = "sparkPoolName", default, skip_serializing_if = "Option::is_none")]
+    pub spark_pool_name: Option<String>,
+    #[serde(rename = "submitterName", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_name: Option<String>,
+    #[serde(rename = "submitterId", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<spark_batch_job::JobType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<spark_batch_job::Result>,
+    #[serde(rename = "schedulerInfo", default, skip_serializing_if = "Option::is_none")]
+    pub scheduler_info: Option<SparkScheduler>,
+    #[serde(rename = "pluginInfo", default, skip_serializing_if = "Option::is_none")]
+    pub plugin_info: Option<SparkServicePlugin>,
+    #[serde(rename = "errorInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_info: Vec<SparkServiceError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub id: i32,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appInfo", default, skip_serializing_if = "Option::is_none")]
+    pub app_info: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<spark_batch_job::State>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub log: Vec<String>,
+}
+pub mod spark_batch_job {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum JobType {
+        SparkBatch,
+        SparkSession,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        Uncertain,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        #[serde(rename = "not_started")]
+        NotStarted,
+        #[serde(rename = "starting")]
+        Starting,
+        #[serde(rename = "idle")]
+        Idle,
+        #[serde(rename = "busy")]
+        Busy,
+        #[serde(rename = "shutting_down")]
+        ShuttingDown,
+        #[serde(rename = "error")]
+        Error,
+        #[serde(rename = "dead")]
+        Dead,
+        #[serde(rename = "killed")]
+        Killed,
+        #[serde(rename = "success")]
+        Success,
+        #[serde(rename = "running")]
+        Running,
+        #[serde(rename = "recovering")]
+        Recovering,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobState {
+    #[serde(rename = "notStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub not_started_at: Option<String>,
+    #[serde(rename = "startingAt", default, skip_serializing_if = "Option::is_none")]
+    pub starting_at: Option<String>,
+    #[serde(rename = "runningAt", default, skip_serializing_if = "Option::is_none")]
+    pub running_at: Option<String>,
+    #[serde(rename = "deadAt", default, skip_serializing_if = "Option::is_none")]
+    pub dead_at: Option<String>,
+    #[serde(rename = "successAt", default, skip_serializing_if = "Option::is_none")]
+    pub success_at: Option<String>,
+    #[serde(rename = "killedAt", default, skip_serializing_if = "Option::is_none")]
+    pub killed_at: Option<String>,
+    #[serde(rename = "recoveringAt", default, skip_serializing_if = "Option::is_none")]
+    pub recovering_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+    #[serde(rename = "jobCreationRequest", default, skip_serializing_if = "Option::is_none")]
+    pub job_creation_request: Option<SparkRequest>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub file: Option<String>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkScheduler {
+    #[serde(rename = "submittedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submitted_at: Option<String>,
+    #[serde(rename = "scheduledAt", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_at: Option<String>,
+    #[serde(rename = "endedAt", default, skip_serializing_if = "Option::is_none")]
+    pub ended_at: Option<String>,
+    #[serde(rename = "cancellationRequestedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_requested_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_scheduler::CurrentState>,
+}
+pub mod spark_scheduler {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Queued,
+        Scheduled,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServicePlugin {
+    #[serde(rename = "preparationStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub preparation_started_at: Option<String>,
+    #[serde(rename = "resourceAcquisitionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub resource_acquisition_started_at: Option<String>,
+    #[serde(rename = "submissionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submission_started_at: Option<String>,
+    #[serde(rename = "monitoringStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub monitoring_started_at: Option<String>,
+    #[serde(rename = "cleanupStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cleanup_started_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_service_plugin::CurrentState>,
+}
+pub mod spark_service_plugin {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Preparation,
+        ResourceAcquisition,
+        Queued,
+        Submission,
+        Monitoring,
+        Cleanup,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServiceError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<spark_service_error::Source>,
+}
+pub mod spark_service_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Source {
+        System,
+        User,
+        Unknown,
+        Dependency,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolInfoListResult {
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<SqlPool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPool {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sku: Option<Sku>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<SqlPoolResourceProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Sku {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tier: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub capacity: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlPoolResourceProperties {
+    #[serde(rename = "maxSizeBytes", default, skip_serializing_if = "Option::is_none")]
+    pub max_size_bytes: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collation: Option<String>,
+    #[serde(rename = "sourceDatabaseId", default, skip_serializing_if = "Option::is_none")]
+    pub source_database_id: Option<String>,
+    #[serde(rename = "recoverableDatabaseId", default, skip_serializing_if = "Option::is_none")]
+    pub recoverable_database_id: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(rename = "restorePointInTime", default, skip_serializing_if = "Option::is_none")]
+    pub restore_point_in_time: Option<String>,
+    #[serde(rename = "createMode", default, skip_serializing_if = "Option::is_none")]
+    pub create_mode: Option<sql_pool_resource_properties::CreateMode>,
+    #[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
+    pub creation_date: Option<String>,
+}
+pub mod sql_pool_resource_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CreateMode {
+        Default,
+        PointInTimeRestore,
+        Recovery,
+        Restore,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Workspace {
+    #[serde(flatten)]
+    pub tracked_resource: TrackedResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<WorkspaceProperties>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<ManagedIdentity>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceProperties {
+    #[serde(rename = "defaultDataLakeStorage", default, skip_serializing_if = "Option::is_none")]
+    pub default_data_lake_storage: Option<DataLakeStorageAccountDetails>,
+    #[serde(rename = "sqlAdministratorLoginPassword", default, skip_serializing_if = "Option::is_none")]
+    pub sql_administrator_login_password: Option<String>,
+    #[serde(rename = "managedResourceGroupName", default, skip_serializing_if = "Option::is_none")]
+    pub managed_resource_group_name: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "sqlAdministratorLogin", default, skip_serializing_if = "Option::is_none")]
+    pub sql_administrator_login: Option<String>,
+    #[serde(rename = "virtualNetworkProfile", default, skip_serializing_if = "Option::is_none")]
+    pub virtual_network_profile: Option<VirtualNetworkProfile>,
+    #[serde(rename = "connectivityEndpoints", default, skip_serializing_if = "Option::is_none")]
+    pub connectivity_endpoints: Option<serde_json::Value>,
+    #[serde(rename = "managedVirtualNetwork", default, skip_serializing_if = "Option::is_none")]
+    pub managed_virtual_network: Option<String>,
+    #[serde(rename = "privateEndpointConnections", default, skip_serializing_if = "Vec::is_empty")]
+    pub private_endpoint_connections: Vec<PrivateEndpointConnection>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub encryption: Option<EncryptionDetails>,
+    #[serde(rename = "workspaceUID", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_uid: Option<String>,
+    #[serde(rename = "extraProperties", default, skip_serializing_if = "Option::is_none")]
+    pub extra_properties: Option<serde_json::Value>,
+    #[serde(rename = "managedVirtualNetworkSettings", default, skip_serializing_if = "Option::is_none")]
+    pub managed_virtual_network_settings: Option<ManagedVirtualNetworkSettings>,
+    #[serde(rename = "workspaceRepositoryConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_repository_configuration: Option<WorkspaceRepositoryConfiguration>,
+    #[serde(rename = "purviewConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub purview_configuration: Option<PurviewConfiguration>,
+    #[serde(rename = "adlaResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub adla_resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DataLakeStorageAccountDetails {
+    #[serde(rename = "accountUrl", default, skip_serializing_if = "Option::is_none")]
+    pub account_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filesystem: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VirtualNetworkProfile {
+    #[serde(rename = "computeSubnetId", default, skip_serializing_if = "Option::is_none")]
+    pub compute_subnet_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpointConnection {
+    #[serde(flatten)]
+    pub proxy_resource: ProxyResource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<PrivateEndpointConnectionProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpointConnectionProperties {
+    #[serde(rename = "privateEndpoint", default, skip_serializing_if = "Option::is_none")]
+    pub private_endpoint: Option<PrivateEndpoint>,
+    #[serde(rename = "privateLinkServiceConnectionState", default, skip_serializing_if = "Option::is_none")]
+    pub private_link_service_connection_state: Option<PrivateLinkServiceConnectionState>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateEndpoint {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PrivateLinkServiceConnectionState {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "actionsRequired", default, skip_serializing_if = "Option::is_none")]
+    pub actions_required: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProxyResource {
+    #[serde(flatten)]
+    pub resource: Resource,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EncryptionDetails {
+    #[serde(rename = "doubleEncryptionEnabled", default, skip_serializing_if = "Option::is_none")]
+    pub double_encryption_enabled: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cmk: Option<CustomerManagedKeyDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CustomerManagedKeyDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<WorkspaceKeyDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceKeyDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "keyVaultUrl", default, skip_serializing_if = "Option::is_none")]
+    pub key_vault_url: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedVirtualNetworkSettings {
+    #[serde(rename = "preventDataExfiltration", default, skip_serializing_if = "Option::is_none")]
+    pub prevent_data_exfiltration: Option<bool>,
+    #[serde(rename = "linkedAccessCheckOnTargetResource", default, skip_serializing_if = "Option::is_none")]
+    pub linked_access_check_on_target_resource: Option<bool>,
+    #[serde(rename = "allowedAadTenantIdsForLinking", default, skip_serializing_if = "Vec::is_empty")]
+    pub allowed_aad_tenant_ids_for_linking: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WorkspaceRepositoryConfiguration {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(rename = "hostName", default, skip_serializing_if = "Option::is_none")]
+    pub host_name: Option<String>,
+    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
+    pub account_name: Option<String>,
+    #[serde(rename = "projectName", default, skip_serializing_if = "Option::is_none")]
+    pub project_name: Option<String>,
+    #[serde(rename = "repositoryName", default, skip_serializing_if = "Option::is_none")]
+    pub repository_name: Option<String>,
+    #[serde(rename = "collaborationBranch", default, skip_serializing_if = "Option::is_none")]
+    pub collaboration_branch: Option<String>,
+    #[serde(rename = "rootFolder", default, skip_serializing_if = "Option::is_none")]
+    pub root_folder: Option<String>,
+    #[serde(rename = "lastCommitId", default, skip_serializing_if = "Option::is_none")]
+    pub last_commit_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
+    pub client_id: Option<String>,
+    #[serde(rename = "clientSecret", default, skip_serializing_if = "Option::is_none")]
+    pub client_secret: Option<GitHubClientSecret>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GitHubClientSecret {
+    #[serde(rename = "byoaSecretAkvUrl", default, skip_serializing_if = "Option::is_none")]
+    pub byoa_secret_akv_url: Option<String>,
+    #[serde(rename = "byoaSecretName", default, skip_serializing_if = "Option::is_none")]
+    pub byoa_secret_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PurviewConfiguration {
+    #[serde(rename = "purviewResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub purview_resource_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedIdentity {
+    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
+    pub principal_id: Option<String>,
+    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
+    pub tenant_id: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<managed_identity::Type>,
+}
+pub mod managed_identity {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        None,
+        SystemAssigned,
+    }
+}
diff --git a/services/svc/synapse/src/package_artifacts_composite_v1/operations.rs b/services/svc/synapse/src/package_artifacts_composite_v1/operations.rs
new file mode 100644
index 0000000000..8f572ed45b
--- /dev/null
+++ b/services/svc/synapse/src/package_artifacts_composite_v1/operations.rs
@@ -0,0 +1,5933 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod kql_scripts {
+    use crate::models::*;
+    pub async fn get_all(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<KqlScriptsResourceCollectionResponse, get_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: KqlScriptsResourceCollectionResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod kql_script {
+    use crate::models::*;
+    pub async fn get_by_name(
+        operation_config: &crate::OperationConfig,
+        kql_script_name: &str,
+    ) -> std::result::Result<KqlScriptResource, get_by_name::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts/{}", operation_config.base_path(), kql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(get_by_name::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_by_name::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_by_name::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_by_name::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: KqlScriptResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_by_name::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_by_name::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_by_name::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_by_name {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        kql_script_name: &str,
+        kql_script: &KqlScriptResource,
+    ) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts/{}", operation_config.base_path(), kql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(kql_script).map_err(create_or_update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: KqlScriptResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(KqlScriptResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_by_name(
+        operation_config: &crate::OperationConfig,
+        kql_script_name: &str,
+    ) -> std::result::Result<delete_by_name::Response, delete_by_name::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts/{}", operation_config.base_path(), kql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_by_name::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_by_name::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_by_name::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_by_name::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_by_name::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_by_name::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_by_name::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_by_name::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_by_name::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_by_name {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename(
+        operation_config: &crate::OperationConfig,
+        kql_script_name: &str,
+        rename_request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename::Response, rename::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts/{}/rename", operation_config.base_path(), kql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(rename::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(rename_request).map_err(rename::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(rename::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| rename::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod spark_configuration {
+    use crate::models::*;
+    pub async fn get_spark_configurations_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SparkConfigurationListResponse, get_spark_configurations_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkconfigurations", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_configurations_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_configurations_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_configurations_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_configurations_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkConfigurationListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_configurations_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_configurations_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_configurations_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_configurations_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_configuration(
+        operation_config: &crate::OperationConfig,
+        spark_configuration_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SparkConfigurationResource, get_spark_configuration::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkconfigurations/{}", operation_config.base_path(), spark_configuration_name);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_configuration::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_configuration::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_configuration::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_configuration::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkConfigurationResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_spark_configuration::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_configuration::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_configuration {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_spark_configuration(
+        operation_config: &crate::OperationConfig,
+        spark_configuration_name: &str,
+        if_match: Option<&str>,
+        spark_configuration: &SparkConfigurationResource,
+    ) -> std::result::Result<create_or_update_spark_configuration::Response, create_or_update_spark_configuration::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkconfigurations/{}", operation_config.base_path(), spark_configuration_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_spark_configuration::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_spark_configuration::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(spark_configuration).map_err(create_or_update_spark_configuration::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_spark_configuration::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_spark_configuration::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkConfigurationResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_spark_configuration::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_spark_configuration::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_spark_configuration::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_spark_configuration {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SparkConfigurationResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_spark_configuration(
+        operation_config: &crate::OperationConfig,
+        spark_configuration_name: &str,
+    ) -> std::result::Result<delete_spark_configuration::Response, delete_spark_configuration::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkconfigurations/{}", operation_config.base_path(), spark_configuration_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_spark_configuration::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_spark_configuration::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_spark_configuration::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_spark_configuration::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_spark_configuration::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_spark_configuration::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_spark_configuration::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_spark_configuration::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_spark_configuration {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_spark_configuration(
+        operation_config: &crate::OperationConfig,
+        spark_configuration_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_spark_configuration::Response, rename_spark_configuration::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkconfigurations/{}/rename",
+            operation_config.base_path(),
+            spark_configuration_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(rename_spark_configuration::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_spark_configuration::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_spark_configuration::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_spark_configuration::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_spark_configuration::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_spark_configuration::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_spark_configuration::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_spark_configuration::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_spark_configuration::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_spark_configuration {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod big_data_pools {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<BigDataPoolResourceInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/bigDataPools", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BigDataPoolResourceInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        big_data_pool_name: &str,
+    ) -> std::result::Result<BigDataPoolResourceInfo, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/bigDataPools/{}", operation_config.base_path(), big_data_pool_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: BigDataPoolResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_flow {
+    use crate::models::*;
+    pub async fn get_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<DataFlowResource, get_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(get_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        if_match: Option<&str>,
+        data_flow: &DataFlowResource,
+    ) -> std::result::Result<create_or_update_data_flow::Response, create_or_update_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(data_flow).map_err(create_or_update_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_data_flow::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_data_flow::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DataFlowResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+    ) -> std::result::Result<delete_data_flow::Response, delete_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_data_flow::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_data_flow::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_data_flow::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_data_flow(
+        operation_config: &crate::OperationConfig,
+        data_flow_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_data_flow::Response, rename_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows/{}/rename", operation_config.base_path(), data_flow_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_data_flow::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_data_flow::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_data_flows_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<DataFlowListResponse, get_data_flows_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/dataflows", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_data_flows_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_data_flows_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_data_flows_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_data_flows_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_data_flows_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_data_flows_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_data_flows_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_data_flows_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod data_flow_debug_session {
+    use crate::models::*;
+    pub async fn create_data_flow_debug_session(
+        operation_config: &crate::OperationConfig,
+        request: &CreateDataFlowDebugSessionRequest,
+    ) -> std::result::Result<create_data_flow_debug_session::Response, create_data_flow_debug_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/createDataFlowDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(create_data_flow_debug_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_data_flow_debug_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(create_data_flow_debug_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_data_flow_debug_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_data_flow_debug_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(create_data_flow_debug_session::Response::Accepted202),
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: CreateDataFlowDebugSessionResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_data_flow_debug_session::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_data_flow_debug_session::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_data_flow_debug_session {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            Ok200(CreateDataFlowDebugSessionResponse),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_data_flow_debug_sessions_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<QueryDataFlowDebugSessionsResponse, query_data_flow_debug_sessions_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryDataFlowDebugSessions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_data_flow_debug_sessions_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_data_flow_debug_sessions_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_data_flow_debug_sessions_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_data_flow_debug_sessions_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryDataFlowDebugSessionsResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_data_flow_debug_sessions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_data_flow_debug_sessions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_data_flow_debug_sessions_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_data_flow_debug_sessions_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_data_flow(
+        operation_config: &crate::OperationConfig,
+        request: &DataFlowDebugPackage,
+    ) -> std::result::Result<AddDataFlowToDebugSessionResponse, add_data_flow::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/addDataFlowToDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(add_data_flow::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_data_flow::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(add_data_flow::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_data_flow::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_data_flow::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AddDataFlowToDebugSessionResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| add_data_flow::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_data_flow::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_data_flow {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_data_flow_debug_session(
+        operation_config: &crate::OperationConfig,
+        request: &DeleteDataFlowDebugSessionRequest,
+    ) -> std::result::Result<(), delete_data_flow_debug_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/deleteDataFlowDebugSession", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(delete_data_flow_debug_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_data_flow_debug_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(delete_data_flow_debug_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_data_flow_debug_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_data_flow_debug_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_data_flow_debug_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_data_flow_debug_session::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_data_flow_debug_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_command(
+        operation_config: &crate::OperationConfig,
+        request: &DataFlowDebugCommandRequest,
+    ) -> std::result::Result<execute_command::Response, execute_command::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/executeDataFlowDebugCommand", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(execute_command::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_command::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(execute_command::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute_command::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_command::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(execute_command::Response::Accepted202),
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DataFlowDebugCommandResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_command::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_command::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_command::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_command {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            Ok200(DataFlowDebugCommandResponse),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod dataset {
+    use crate::models::*;
+    pub async fn get_datasets_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<DatasetListResponse, get_datasets_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_datasets_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_datasets_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_datasets_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_datasets_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_datasets_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_datasets_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_datasets_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_datasets_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<DatasetResource, get_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(get_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_dataset::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        if_match: Option<&str>,
+        dataset: &DatasetResource,
+    ) -> std::result::Result<create_or_update_dataset::Response, create_or_update_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(dataset).map_err(create_or_update_dataset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: DatasetResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_dataset::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_dataset::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(DatasetResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+    ) -> std::result::Result<delete_dataset::Response, delete_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_dataset::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_dataset::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_dataset::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_dataset(
+        operation_config: &crate::OperationConfig,
+        dataset_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_dataset::Response, rename_dataset::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/datasets/{}/rename", operation_config.base_path(), dataset_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_dataset::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_dataset::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_dataset::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_dataset::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_dataset::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_dataset::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_dataset::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| rename_dataset::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_dataset::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_dataset {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod linked_service {
+    use crate::models::*;
+    pub async fn get_linked_services_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<LinkedServiceListResponse, get_linked_services_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_linked_services_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_linked_services_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_linked_services_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_linked_services_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_services_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_services_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_linked_services_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_linked_services_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<LinkedServiceResource, get_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(get_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_linked_service::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        if_match: Option<&str>,
+        linked_service: &LinkedServiceResource,
+    ) -> std::result::Result<create_or_update_linked_service::Response, create_or_update_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(linked_service).map_err(create_or_update_linked_service::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LinkedServiceResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_linked_service::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_linked_service::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(LinkedServiceResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+    ) -> std::result::Result<delete_linked_service::Response, delete_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_linked_service::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_linked_service::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_linked_service::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_linked_service(
+        operation_config: &crate::OperationConfig,
+        linked_service_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_linked_service::Response, rename_linked_service::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/linkedservices/{}/rename", operation_config.base_path(), linked_service_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_linked_service::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_linked_service::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_linked_service::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_linked_service::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_linked_service::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_linked_service::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_linked_service::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_linked_service::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_linked_service::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_linked_service {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod workspace_git_repo_management {
+    use crate::models::*;
+    pub async fn get_git_hub_access_token(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+        git_hub_access_token_request: &GitHubAccessTokenRequest,
+    ) -> std::result::Result<GitHubAccessTokenResponse, get_git_hub_access_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/getGitHubAccessToken", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_git_hub_access_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_git_hub_access_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        let req_body = azure_core::to_json(git_hub_access_token_request).map_err(get_git_hub_access_token::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_git_hub_access_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_git_hub_access_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GitHubAccessTokenResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_git_hub_access_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_git_hub_access_token::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_git_hub_access_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod integration_runtimes {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<IntegrationRuntimeListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/integrationRuntimes", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IntegrationRuntimeListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        integration_runtime_name: &str,
+    ) -> std::result::Result<IntegrationRuntimeResource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/integrationRuntimes/{}", operation_config.base_path(), integration_runtime_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: IntegrationRuntimeResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod library {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<LibraryListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn flush(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<flush::Response, flush::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}/flush", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(flush::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(flush::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(flush::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(flush::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(flush::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| flush::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(flush::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| flush::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(flush::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod flush {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_operation_result(
+        operation_config: &crate::OperationConfig,
+        operation_id: &str,
+    ) -> std::result::Result<get_operation_result::Response, get_operation_result::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraryOperationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get_operation_result::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_operation_result::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_operation_result::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_operation_result::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(get_operation_result::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: OperationResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(get_operation_result::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_operation_result::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_operation_result::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_operation_result {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(LibraryResource),
+            Accepted202(OperationResult),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, library_name: &str) -> std::result::Result<LibraryResource, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<create::Response, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(create::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create::Response::Accepted202(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        library_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/libraries/{}", operation_config.base_path(), library_name);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete::Response::Ok200),
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: LibraryResourceInfo =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(delete::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::CONFLICT => Err(delete::Error::Conflict409 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202(LibraryResourceInfo),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            Conflict409 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod notebook {
+    use crate::models::*;
+    pub async fn get_notebooks_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<NotebookListResponse, get_notebooks_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_notebooks_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebooks_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_notebooks_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebooks_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebooks_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebooks_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebooks_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebooks_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_notebook_summary_by_work_space(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<NotebookListResponse, get_notebook_summary_by_work_space::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooksSummary", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_notebook_summary_by_work_space::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebook_summary_by_work_space::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_notebook_summary_by_work_space::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebook_summary_by_work_space::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebook_summary_by_work_space::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_notebook_summary_by_work_space::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebook_summary_by_work_space::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebook_summary_by_work_space {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<NotebookResource, get_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(get_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_notebook::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        if_match: Option<&str>,
+        notebook: &NotebookResource,
+    ) -> std::result::Result<create_or_update_notebook::Response, create_or_update_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(notebook).map_err(create_or_update_notebook::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: NotebookResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_notebook::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_notebook::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(NotebookResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+    ) -> std::result::Result<delete_notebook::Response, delete_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_notebook::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_notebook::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_notebook::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_notebook(
+        operation_config: &crate::OperationConfig,
+        notebook_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_notebook::Response, rename_notebook::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebooks/{}/rename", operation_config.base_path(), notebook_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_notebook::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_notebook::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_notebook::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_notebook::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_notebook::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_notebook::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_notebook::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_notebook::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_notebook::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_notebook {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod notebook_operation_result {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig, operation_id: &str) -> std::result::Result<get::Response, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/notebookOperationResults/{}", operation_config.base_path(), operation_id);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(get::Response::Ok200),
+            http::StatusCode::CREATED => Ok(get::Response::Created201),
+            http::StatusCode::ACCEPTED => Ok(get::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(get::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Created201,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline {
+    use crate::models::*;
+    pub async fn get_pipelines_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<PipelineListResponse, get_pipelines_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_pipelines_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipelines_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_pipelines_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipelines_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipelines_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipelines_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipelines_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipelines_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<PipelineResource, get_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(get_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_pipeline::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        if_match: Option<&str>,
+        pipeline: &PipelineResource,
+    ) -> std::result::Result<create_or_update_pipeline::Response, create_or_update_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(pipeline).map_err(create_or_update_pipeline::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_pipeline::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_pipeline::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(PipelineResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+    ) -> std::result::Result<delete_pipeline::Response, delete_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_pipeline::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_pipeline::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_pipeline::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_pipeline(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_pipeline::Response, rename_pipeline::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}/rename", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_pipeline::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_pipeline::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_pipeline::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_pipeline::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_pipeline::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_pipeline::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_pipeline::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_pipeline::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_pipeline::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_pipeline {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        reference_pipeline_run_id: Option<&str>,
+        is_recovery: Option<bool>,
+        start_activity_name: Option<&str>,
+        parameters: Option<&ParameterValueSpecification>,
+    ) -> std::result::Result<CreateRunResponse, create_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelines/{}/createRun", operation_config.base_path(), pipeline_name);
+        let mut url = url::Url::parse(url_str).map_err(create_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(reference_pipeline_run_id) = reference_pipeline_run_id {
+            url.query_pairs_mut()
+                .append_pair("referencePipelineRunId", reference_pipeline_run_id);
+        }
+        if let Some(is_recovery) = is_recovery {
+            url.query_pairs_mut().append_pair("isRecovery", is_recovery.to_string().as_str());
+        }
+        if let Some(start_activity_name) = start_activity_name {
+            url.query_pairs_mut().append_pair("startActivityName", start_activity_name);
+        }
+        let req_body = if let Some(parameters) = parameters {
+            azure_core::to_json(parameters).map_err(create_pipeline_run::Error::SerializeError)?
+        } else {
+            bytes::Bytes::from_static(azure_core::EMPTY_BODY)
+        };
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: CreateRunResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod pipeline_run {
+    use crate::models::*;
+    pub async fn query_pipeline_runs_by_workspace(
+        operation_config: &crate::OperationConfig,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<PipelineRunsQueryResponse, query_pipeline_runs_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryPipelineRuns", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_pipeline_runs_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_pipeline_runs_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_pipeline_runs_by_workspace::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_pipeline_runs_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_pipeline_runs_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_pipeline_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_pipeline_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_pipeline_runs_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_pipeline_runs_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        run_id: &str,
+    ) -> std::result::Result<PipelineRun, get_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelineruns/{}", operation_config.base_path(), run_id);
+        let mut url = url::Url::parse(url_str).map_err(get_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: PipelineRun = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_activity_runs(
+        operation_config: &crate::OperationConfig,
+        pipeline_name: &str,
+        run_id: &str,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<ActivityRunsQueryResponse, query_activity_runs::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/pipelines/{}/pipelineruns/{}/queryActivityruns",
+            operation_config.base_path(),
+            pipeline_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(query_activity_runs::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_activity_runs::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_activity_runs::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(query_activity_runs::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_activity_runs::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ActivityRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_activity_runs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_activity_runs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_activity_runs::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_activity_runs {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_pipeline_run(
+        operation_config: &crate::OperationConfig,
+        run_id: &str,
+        is_recursive: Option<bool>,
+    ) -> std::result::Result<(), cancel_pipeline_run::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/pipelineruns/{}/cancel", operation_config.base_path(), run_id);
+        let mut url = url::Url::parse(url_str).map_err(cancel_pipeline_run::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_pipeline_run::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(is_recursive) = is_recursive {
+            url.query_pairs_mut().append_pair("isRecursive", is_recursive.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel_pipeline_run::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_pipeline_run::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_pipeline_run::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_pipeline_run::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_pipeline_run {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod spark_job_definition {
+    use crate::models::*;
+    pub async fn get_spark_job_definitions_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SparkJobDefinitionsListResponse, get_spark_job_definitions_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_definitions_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_definitions_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_job_definitions_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_definitions_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definitions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definitions_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_job_definitions_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_definitions_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SparkJobDefinitionResource, get_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_spark_job_definition::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        if_match: Option<&str>,
+        spark_job_definition: &SparkJobDefinitionResource,
+    ) -> std::result::Result<create_or_update_spark_job_definition::Response, create_or_update_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(spark_job_definition).map_err(create_or_update_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobDefinitionResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_spark_job_definition::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SparkJobDefinitionResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+    ) -> std::result::Result<delete_spark_job_definition::Response, delete_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sparkJobDefinitions/{}", operation_config.base_path(), spark_job_definition_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(delete_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_spark_job_definition::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_spark_job_definition::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_spark_job_definition::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+    ) -> std::result::Result<execute_spark_job_definition::Response, execute_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkJobDefinitions/{}/execute",
+            operation_config.base_path(),
+            spark_job_definition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(execute_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(execute_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_spark_job_definition::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(execute_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| execute_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202(SparkBatchJob),
+            Ok200(SparkBatchJob),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_spark_job_definition::Response, rename_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sparkJobDefinitions/{}/rename",
+            operation_config.base_path(),
+            spark_job_definition_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(rename_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rename_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_spark_job_definition::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_spark_job_definition::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn debug_spark_job_definition(
+        operation_config: &crate::OperationConfig,
+        spark_job_definition_azure_resource: &SparkJobDefinitionResource,
+    ) -> std::result::Result<debug_spark_job_definition::Response, debug_spark_job_definition::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/debugSparkJobDefinition", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(debug_spark_job_definition::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(debug_spark_job_definition::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body =
+            azure_core::to_json(spark_job_definition_azure_resource).map_err(debug_spark_job_definition::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(debug_spark_job_definition::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(debug_spark_job_definition::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(debug_spark_job_definition::Response::Accepted202(rsp_value))
+            }
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(debug_spark_job_definition::Response::Ok200(rsp_value))
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| debug_spark_job_definition::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(debug_spark_job_definition::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod debug_spark_job_definition {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202(SparkBatchJob),
+            Ok200(SparkBatchJob),
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod sql_pools {
+    use crate::models::*;
+    pub async fn list(operation_config: &crate::OperationConfig) -> std::result::Result<SqlPoolInfoListResult, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlPools", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlPoolInfoListResult =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get(operation_config: &crate::OperationConfig, sql_pool_name: &str) -> std::result::Result<SqlPool, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlPools/{}", operation_config.base_path(), sql_pool_name);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlPool =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod sql_script {
+    use crate::models::*;
+    pub async fn get_sql_scripts_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<SqlScriptsListResponse, get_sql_scripts_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_scripts_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_scripts_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_sql_scripts_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_scripts_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptsListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_scripts_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_scripts_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_sql_scripts_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_sql_scripts_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<SqlScriptResource, get_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_sql_script::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        if_match: Option<&str>,
+        sql_script: &SqlScriptResource,
+    ) -> std::result::Result<create_or_update_sql_script::Response, create_or_update_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(sql_script).map_err(create_or_update_sql_script::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlScriptResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_sql_script::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_sql_script::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(SqlScriptResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+    ) -> std::result::Result<delete_sql_script::Response, delete_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_sql_script::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_sql_script::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_sql_script::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| delete_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename_sql_script(
+        operation_config: &crate::OperationConfig,
+        sql_script_name: &str,
+        request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename_sql_script::Response, rename_sql_script::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sqlScripts/{}/rename", operation_config.base_path(), sql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(rename_sql_script::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename_sql_script::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(request).map_err(rename_sql_script::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename_sql_script::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rename_sql_script::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename_sql_script::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename_sql_script::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rename_sql_script::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename_sql_script::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename_sql_script {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod trigger {
+    use crate::models::*;
+    pub async fn get_triggers_by_workspace(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<TriggerListResponse, get_triggers_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_triggers_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_triggers_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_triggers_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_triggers_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerListResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_triggers_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_triggers_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_triggers_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_triggers_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        if_none_match: Option<&str>,
+    ) -> std::result::Result<TriggerResource, get_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(get_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_none_match) = if_none_match {
+            req_builder = req_builder.header("If-None-Match", if_none_match);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            http::StatusCode::NOT_MODIFIED => Err(get_trigger::Error::NotModified304 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotModified304 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        if_match: Option<&str>,
+        trigger: &TriggerResource,
+    ) -> std::result::Result<create_or_update_trigger::Response, create_or_update_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(if_match) = if_match {
+            req_builder = req_builder.header("If-Match", if_match);
+        }
+        let req_body = azure_core::to_json(trigger).map_err(create_or_update_trigger::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_or_update_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update_trigger::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update_trigger::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<delete_trigger::Response, delete_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_trigger::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_trigger::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_trigger::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn subscribe_trigger_to_events(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<subscribe_trigger_to_events::Response, subscribe_trigger_to_events::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/subscribeToEvents", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(subscribe_trigger_to_events::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(subscribe_trigger_to_events::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(subscribe_trigger_to_events::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(subscribe_trigger_to_events::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| subscribe_trigger_to_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(subscribe_trigger_to_events::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(subscribe_trigger_to_events::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| subscribe_trigger_to_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(subscribe_trigger_to_events::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod subscribe_trigger_to_events {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerSubscriptionOperationStatus),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_event_subscription_status(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<TriggerSubscriptionOperationStatus, get_event_subscription_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/getEventSubscriptionStatus",
+            operation_config.base_path(),
+            trigger_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_event_subscription_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_event_subscription_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_event_subscription_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_event_subscription_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_subscription_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_subscription_status::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_event_subscription_status::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_event_subscription_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn unsubscribe_trigger_from_events(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<unsubscribe_trigger_from_events::Response, unsubscribe_trigger_from_events::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/unsubscribeFromEvents", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(unsubscribe_trigger_from_events::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(unsubscribe_trigger_from_events::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(unsubscribe_trigger_from_events::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(unsubscribe_trigger_from_events::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerSubscriptionOperationStatus = serde_json::from_slice(rsp_body)
+                    .map_err(|source| unsubscribe_trigger_from_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(unsubscribe_trigger_from_events::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(unsubscribe_trigger_from_events::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| unsubscribe_trigger_from_events::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(unsubscribe_trigger_from_events::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod unsubscribe_trigger_from_events {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(TriggerSubscriptionOperationStatus),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn start_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<(), start_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/start", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(start_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(start_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(start_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(start_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| start_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(start_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod start_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn stop_trigger(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+    ) -> std::result::Result<(), stop_trigger::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/triggers/{}/stop", operation_config.base_path(), trigger_name);
+        let mut url = url::Url::parse(url_str).map_err(stop_trigger::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(stop_trigger::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(stop_trigger::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(stop_trigger::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError =
+                    serde_json::from_slice(rsp_body).map_err(|source| stop_trigger::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(stop_trigger::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod stop_trigger {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod trigger_run {
+    use crate::models::*;
+    pub async fn rerun_trigger_instance(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<(), rerun_trigger_instance::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/triggerRuns/{}/rerun",
+            operation_config.base_path(),
+            trigger_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(rerun_trigger_instance::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rerun_trigger_instance::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(rerun_trigger_instance::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(rerun_trigger_instance::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| rerun_trigger_instance::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rerun_trigger_instance::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rerun_trigger_instance {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_trigger_instance(
+        operation_config: &crate::OperationConfig,
+        trigger_name: &str,
+        run_id: &str,
+    ) -> std::result::Result<(), cancel_trigger_instance::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/triggers/{}/triggerRuns/{}/cancel",
+            operation_config.base_path(),
+            trigger_name,
+            run_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_trigger_instance::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_trigger_instance::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(cancel_trigger_instance::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_trigger_instance::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_trigger_instance::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(cancel_trigger_instance::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod cancel_trigger_instance {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn query_trigger_runs_by_workspace(
+        operation_config: &crate::OperationConfig,
+        filter_parameters: &RunFilterParameters,
+    ) -> std::result::Result<TriggerRunsQueryResponse, query_trigger_runs_by_workspace::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/queryTriggerRuns", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(query_trigger_runs_by_workspace::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(query_trigger_runs_by_workspace::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(filter_parameters).map_err(query_trigger_runs_by_workspace::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(query_trigger_runs_by_workspace::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(query_trigger_runs_by_workspace::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TriggerRunsQueryResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_trigger_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: CloudError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| query_trigger_runs_by_workspace::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(query_trigger_runs_by_workspace::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod query_trigger_runs_by_workspace {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::CloudError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod workspace {
+    use crate::models::*;
+    pub async fn get(operation_config: &crate::OperationConfig) -> std::result::Result<Workspace, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/workspace", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: Workspace =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_kql_script_2021_06_preview/mod.rs b/services/svc/synapse/src/package_kql_script_2021_06_preview/mod.rs
new file mode 100644
index 0000000000..ed72a17404
--- /dev/null
+++ b/services/svc/synapse/src/package_kql_script_2021_06_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-06-01-preview";
diff --git a/services/svc/synapse/src/package_kql_script_2021_06_preview/models.rs b/services/svc/synapse/src/package_kql_script_2021_06_preview/models.rs
new file mode 100644
index 0000000000..e77fcb9eb7
--- /dev/null
+++ b/services/svc/synapse/src/package_kql_script_2021_06_preview/models.rs
@@ -0,0 +1,84 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KqlScriptsResourceCollectionResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<KqlScriptResource>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KqlScriptResource {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<KqlScript>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KqlScript {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub content: Option<kql_script::Content>,
+}
+pub mod kql_script {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Content {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub query: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub metadata: Option<content::Metadata>,
+        #[serde(rename = "currentConnection", default, skip_serializing_if = "Option::is_none")]
+        pub current_connection: Option<content::CurrentConnection>,
+    }
+    pub mod content {
+        use super::*;
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        pub struct Metadata {
+            #[serde(default, skip_serializing_if = "Option::is_none")]
+            pub language: Option<String>,
+        }
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        pub struct CurrentConnection {
+            #[serde(default, skip_serializing_if = "Option::is_none")]
+            pub name: Option<String>,
+            #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+            pub type_: Option<String>,
+        }
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorResponse>,
+    #[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_info: Vec<ErrorAdditionalInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorAdditionalInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ArtifactRenameRequest {
+    #[serde(rename = "newName", default, skip_serializing_if = "Option::is_none")]
+    pub new_name: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_kql_script_2021_06_preview/operations.rs b/services/svc/synapse/src/package_kql_script_2021_06_preview/operations.rs
new file mode 100644
index 0000000000..314b1e9c83
--- /dev/null
+++ b/services/svc/synapse/src/package_kql_script_2021_06_preview/operations.rs
@@ -0,0 +1,344 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod kql_scripts {
+    use crate::models::*;
+    pub async fn get_all(
+        operation_config: &crate::OperationConfig,
+    ) -> std::result::Result<KqlScriptsResourceCollectionResponse, get_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: KqlScriptsResourceCollectionResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod kql_script {
+    use crate::models::*;
+    pub async fn get_by_name(
+        operation_config: &crate::OperationConfig,
+        kql_script_name: &str,
+    ) -> std::result::Result<KqlScriptResource, get_by_name::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts/{}", operation_config.base_path(), kql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(get_by_name::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_by_name::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_by_name::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_by_name::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: KqlScriptResource =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_by_name::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| get_by_name::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_by_name::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_by_name {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_or_update(
+        operation_config: &crate::OperationConfig,
+        kql_script_name: &str,
+        kql_script: &KqlScriptResource,
+    ) -> std::result::Result<create_or_update::Response, create_or_update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts/{}", operation_config.base_path(), kql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(create_or_update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_or_update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(kql_script).map_err(create_or_update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_or_update::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_or_update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: KqlScriptResource = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(create_or_update::Response::Ok200(rsp_value))
+            }
+            http::StatusCode::ACCEPTED => Ok(create_or_update::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_or_update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(create_or_update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod create_or_update {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200(KqlScriptResource),
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete_by_name(
+        operation_config: &crate::OperationConfig,
+        kql_script_name: &str,
+    ) -> std::result::Result<delete_by_name::Response, delete_by_name::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts/{}", operation_config.base_path(), kql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(delete_by_name::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete_by_name::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete_by_name::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(delete_by_name::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(delete_by_name::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(delete_by_name::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete_by_name::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete_by_name::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete_by_name::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete_by_name {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn rename(
+        operation_config: &crate::OperationConfig,
+        kql_script_name: &str,
+        rename_request: &ArtifactRenameRequest,
+    ) -> std::result::Result<rename::Response, rename::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/kqlScripts/{}/rename", operation_config.base_path(), kql_script_name);
+        let mut url = url::Url::parse(url_str).map_err(rename::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(rename::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(rename_request).map_err(rename::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(rename::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(rename::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(rename::Response::Ok200),
+            http::StatusCode::ACCEPTED => Ok(rename::Response::Accepted202),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| rename::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(rename::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod rename {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Ok200,
+            Accepted202,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_metadata_2021_07_01_preview/mod.rs b/services/svc/synapse/src/package_metadata_2021_07_01_preview/mod.rs
new file mode 100644
index 0000000000..855c1a407f
--- /dev/null
+++ b/services/svc/synapse/src/package_metadata_2021_07_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-07-01-preview";
diff --git a/services/svc/synapse/src/package_metadata_2021_07_01_preview/models.rs b/services/svc/synapse/src/package_metadata_2021_07_01_preview/models.rs
new file mode 100644
index 0000000000..7ecf0d9b9e
--- /dev/null
+++ b/services/svc/synapse/src/package_metadata_2021_07_01_preview/models.rs
@@ -0,0 +1,66 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetastoreRegistrationResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<RequestStatus>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetastoreUpdationResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<RequestStatus>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetastoreRequestSuccessResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<ResourceStatus>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum ResourceStatus {
+    Creating,
+    Created,
+    Failed,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum RequestStatus {
+    Running,
+    Completed,
+    Failed,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetastoreRegisterObject {
+    #[serde(rename = "inputFolder")]
+    pub input_folder: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MetastoreUpdateObject {
+    #[serde(rename = "inputFolder")]
+    pub input_folder: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<ErrorResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorResponse>,
+    #[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub additional_info: Vec<ErrorAdditionalInfo>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorAdditionalInfo {
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub info: Option<serde_json::Value>,
+}
diff --git a/services/svc/synapse/src/package_metadata_2021_07_01_preview/operations.rs b/services/svc/synapse/src/package_metadata_2021_07_01_preview/operations.rs
new file mode 100644
index 0000000000..a635bc09ca
--- /dev/null
+++ b/services/svc/synapse/src/package_metadata_2021_07_01_preview/operations.rs
@@ -0,0 +1,258 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod metastore {
+    use crate::models::*;
+    pub async fn get_database_operations(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+    ) -> std::result::Result<MetastoreRequestSuccessResponse, get_database_operations::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/metastore/create-database-operations/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(get_database_operations::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_database_operations::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_database_operations::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_database_operations::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetastoreRequestSuccessResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_database_operations::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_database_operations::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_database_operations::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_database_operations {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn register(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+        register_body: &MetastoreRegisterObject,
+    ) -> std::result::Result<MetastoreRegistrationResponse, register::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/metastore/create-database-operations/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(register::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(register::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(register_body).map_err(register::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(register::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(register::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetastoreRegistrationResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| register::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| register::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(register::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod register {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        id: &str,
+        update_body: &MetastoreUpdateObject,
+    ) -> std::result::Result<MetastoreUpdationResponse, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/metastore/update-database-operations/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(update_body).map_err(update::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::CREATED => {
+                let rsp_body = rsp.body();
+                let rsp_value: MetastoreUpdationResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(operation_config: &crate::OperationConfig, id: &str) -> std::result::Result<(), delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/metastore/databases/{}", operation_config.base_path(), id);
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorContract =
+                    serde_json::from_slice(rsp_body).map_err(|source| delete::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(delete::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorContract,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_monitoring_2019_11_01_preview/mod.rs b/services/svc/synapse/src/package_monitoring_2019_11_01_preview/mod.rs
new file mode 100644
index 0000000000..bbf48c6728
--- /dev/null
+++ b/services/svc/synapse/src/package_monitoring_2019_11_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-11-01-preview";
diff --git a/services/svc/synapse/src/package_monitoring_2019_11_01_preview/models.rs b/services/svc/synapse/src/package_monitoring_2019_11_01_preview/models.rs
new file mode 100644
index 0000000000..a4ca7f6427
--- /dev/null
+++ b/services/svc/synapse/src/package_monitoring_2019_11_01_preview/models.rs
@@ -0,0 +1,49 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobListViewResponse {
+    #[serde(rename = "nJobs", default, skip_serializing_if = "Option::is_none")]
+    pub n_jobs: Option<i32>,
+    #[serde(rename = "sparkJobs", default, skip_serializing_if = "Vec::is_empty")]
+    pub spark_jobs: Vec<SparkJob>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJob {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub submitter: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<String>,
+    #[serde(rename = "sparkApplicationId", default, skip_serializing_if = "Option::is_none")]
+    pub spark_application_id: Option<String>,
+    #[serde(rename = "livyId", default, skip_serializing_if = "Option::is_none")]
+    pub livy_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub timing: Vec<String>,
+    #[serde(rename = "sparkJobDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub spark_job_definition: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub pipeline: Vec<SparkJob>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<String>,
+    #[serde(rename = "submitTime", default, skip_serializing_if = "Option::is_none")]
+    pub submit_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(rename = "queuedDuration", default, skip_serializing_if = "Option::is_none")]
+    pub queued_duration: Option<String>,
+    #[serde(rename = "runningDuration", default, skip_serializing_if = "Option::is_none")]
+    pub running_duration: Option<String>,
+    #[serde(rename = "totalDuration", default, skip_serializing_if = "Option::is_none")]
+    pub total_duration: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlQueryStringDataModel {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_monitoring_2019_11_01_preview/operations.rs b/services/svc/synapse/src/package_monitoring_2019_11_01_preview/operations.rs
new file mode 100644
index 0000000000..c6c169d90f
--- /dev/null
+++ b/services/svc/synapse/src/package_monitoring_2019_11_01_preview/operations.rs
@@ -0,0 +1,148 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod monitoring {
+    use crate::models::*;
+    pub async fn get_spark_job_list(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+    ) -> std::result::Result<SparkJobListViewResponse, get_spark_job_list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/monitoring/workloadTypes/spark/Applications", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_job_list::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobListViewResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_job_list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_sql_job_query_string(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+        filter: Option<&str>,
+        orderby: Option<&str>,
+        skip: Option<&str>,
+    ) -> std::result::Result<SqlQueryStringDataModel, get_sql_job_query_string::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/monitoring/workloadTypes/sql/querystring", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_job_query_string::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_job_query_string::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("filter", filter);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("skip", skip);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_sql_job_query_string::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_job_query_string::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlQueryStringDataModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_job_query_string::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_sql_job_query_string::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_sql_job_query_string {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_monitoring_2020_12_01/mod.rs b/services/svc/synapse/src/package_monitoring_2020_12_01/mod.rs
new file mode 100644
index 0000000000..295814b1a2
--- /dev/null
+++ b/services/svc/synapse/src/package_monitoring_2020_12_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-12-01";
diff --git a/services/svc/synapse/src/package_monitoring_2020_12_01/models.rs b/services/svc/synapse/src/package_monitoring_2020_12_01/models.rs
new file mode 100644
index 0000000000..a4ca7f6427
--- /dev/null
+++ b/services/svc/synapse/src/package_monitoring_2020_12_01/models.rs
@@ -0,0 +1,49 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJobListViewResponse {
+    #[serde(rename = "nJobs", default, skip_serializing_if = "Option::is_none")]
+    pub n_jobs: Option<i32>,
+    #[serde(rename = "sparkJobs", default, skip_serializing_if = "Vec::is_empty")]
+    pub spark_jobs: Vec<SparkJob>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkJob {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub submitter: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub compute: Option<String>,
+    #[serde(rename = "sparkApplicationId", default, skip_serializing_if = "Option::is_none")]
+    pub spark_application_id: Option<String>,
+    #[serde(rename = "livyId", default, skip_serializing_if = "Option::is_none")]
+    pub livy_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub timing: Vec<String>,
+    #[serde(rename = "sparkJobDefinition", default, skip_serializing_if = "Option::is_none")]
+    pub spark_job_definition: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub pipeline: Vec<SparkJob>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<String>,
+    #[serde(rename = "submitTime", default, skip_serializing_if = "Option::is_none")]
+    pub submit_time: Option<String>,
+    #[serde(rename = "endTime", default, skip_serializing_if = "Option::is_none")]
+    pub end_time: Option<String>,
+    #[serde(rename = "queuedDuration", default, skip_serializing_if = "Option::is_none")]
+    pub queued_duration: Option<String>,
+    #[serde(rename = "runningDuration", default, skip_serializing_if = "Option::is_none")]
+    pub running_duration: Option<String>,
+    #[serde(rename = "totalDuration", default, skip_serializing_if = "Option::is_none")]
+    pub total_duration: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SqlQueryStringDataModel {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_monitoring_2020_12_01/operations.rs b/services/svc/synapse/src/package_monitoring_2020_12_01/operations.rs
new file mode 100644
index 0000000000..c6c169d90f
--- /dev/null
+++ b/services/svc/synapse/src/package_monitoring_2020_12_01/operations.rs
@@ -0,0 +1,148 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod monitoring {
+    use crate::models::*;
+    pub async fn get_spark_job_list(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+    ) -> std::result::Result<SparkJobListViewResponse, get_spark_job_list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/monitoring/workloadTypes/spark/Applications", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_job_list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_job_list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_job_list::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_job_list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkJobListViewResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_job_list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_job_list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_job_list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_sql_job_query_string(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+        filter: Option<&str>,
+        orderby: Option<&str>,
+        skip: Option<&str>,
+    ) -> std::result::Result<SqlQueryStringDataModel, get_sql_job_query_string::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/monitoring/workloadTypes/sql/querystring", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_sql_job_query_string::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_sql_job_query_string::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(filter) = filter {
+            url.query_pairs_mut().append_pair("filter", filter);
+        }
+        if let Some(orderby) = orderby {
+            url.query_pairs_mut().append_pair("$orderby", orderby);
+        }
+        if let Some(skip) = skip {
+            url.query_pairs_mut().append_pair("skip", skip);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(get_sql_job_query_string::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_sql_job_query_string::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SqlQueryStringDataModel = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_sql_job_query_string::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_sql_job_query_string::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_sql_job_query_string {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_spark_2019_11_01_preview/mod.rs b/services/svc/synapse/src/package_spark_2019_11_01_preview/mod.rs
new file mode 100644
index 0000000000..bbf48c6728
--- /dev/null
+++ b/services/svc/synapse/src/package_spark_2019_11_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-11-01-preview";
diff --git a/services/svc/synapse/src/package_spark_2019_11_01_preview/models.rs b/services/svc/synapse/src/package_spark_2019_11_01_preview/models.rs
new file mode 100644
index 0000000000..e9d918656e
--- /dev/null
+++ b/services/svc/synapse/src/package_spark_2019_11_01_preview/models.rs
@@ -0,0 +1,393 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobCollection {
+    pub from: i32,
+    pub total: i32,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sessions: Vec<SparkBatchJob>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJob {
+    #[serde(rename = "livyInfo", default, skip_serializing_if = "Option::is_none")]
+    pub livy_info: Option<SparkBatchJobState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "workspaceName", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_name: Option<String>,
+    #[serde(rename = "sparkPoolName", default, skip_serializing_if = "Option::is_none")]
+    pub spark_pool_name: Option<String>,
+    #[serde(rename = "submitterName", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_name: Option<String>,
+    #[serde(rename = "submitterId", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<spark_batch_job::JobType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<spark_batch_job::Result>,
+    #[serde(rename = "schedulerInfo", default, skip_serializing_if = "Option::is_none")]
+    pub scheduler_info: Option<SparkScheduler>,
+    #[serde(rename = "pluginInfo", default, skip_serializing_if = "Option::is_none")]
+    pub plugin_info: Option<SparkServicePlugin>,
+    #[serde(rename = "errorInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_info: Vec<SparkServiceError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub id: i32,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appInfo", default, skip_serializing_if = "Option::is_none")]
+    pub app_info: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub log: Vec<String>,
+}
+pub mod spark_batch_job {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum JobType {
+        SparkBatch,
+        SparkSession,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        Uncertain,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobState {
+    #[serde(rename = "notStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub not_started_at: Option<String>,
+    #[serde(rename = "startingAt", default, skip_serializing_if = "Option::is_none")]
+    pub starting_at: Option<String>,
+    #[serde(rename = "runningAt", default, skip_serializing_if = "Option::is_none")]
+    pub running_at: Option<String>,
+    #[serde(rename = "deadAt", default, skip_serializing_if = "Option::is_none")]
+    pub dead_at: Option<String>,
+    #[serde(rename = "successAt", default, skip_serializing_if = "Option::is_none")]
+    pub success_at: Option<String>,
+    #[serde(rename = "killedAt", default, skip_serializing_if = "Option::is_none")]
+    pub killed_at: Option<String>,
+    #[serde(rename = "recoveringAt", default, skip_serializing_if = "Option::is_none")]
+    pub recovering_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+    #[serde(rename = "jobCreationRequest", default, skip_serializing_if = "Option::is_none")]
+    pub job_creation_request: Option<SparkRequest>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkScheduler {
+    #[serde(rename = "submittedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submitted_at: Option<String>,
+    #[serde(rename = "scheduledAt", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_at: Option<String>,
+    #[serde(rename = "endedAt", default, skip_serializing_if = "Option::is_none")]
+    pub ended_at: Option<String>,
+    #[serde(rename = "cancellationRequestedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_requested_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_scheduler::CurrentState>,
+}
+pub mod spark_scheduler {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Queued,
+        Scheduled,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServicePlugin {
+    #[serde(rename = "preparationStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub preparation_started_at: Option<String>,
+    #[serde(rename = "resourceAcquisitionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub resource_acquisition_started_at: Option<String>,
+    #[serde(rename = "submissionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submission_started_at: Option<String>,
+    #[serde(rename = "monitoringStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub monitoring_started_at: Option<String>,
+    #[serde(rename = "cleanupStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cleanup_started_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_service_plugin::CurrentState>,
+}
+pub mod spark_service_plugin {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Preparation,
+        ResourceAcquisition,
+        Queued,
+        Submission,
+        Monitoring,
+        Cleanup,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServiceError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<spark_service_error::Source>,
+}
+pub mod spark_service_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Source {
+        System,
+        User,
+        Unknown,
+        Dependency,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub file: Option<String>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    pub name: String,
+    pub file: String,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSessionCollection {
+    pub from: i32,
+    pub total: i32,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sessions: Vec<SparkSession>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSession {
+    #[serde(rename = "livyInfo", default, skip_serializing_if = "Option::is_none")]
+    pub livy_info: Option<SparkSessionState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "workspaceName", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_name: Option<String>,
+    #[serde(rename = "sparkPoolName", default, skip_serializing_if = "Option::is_none")]
+    pub spark_pool_name: Option<String>,
+    #[serde(rename = "submitterName", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_name: Option<String>,
+    #[serde(rename = "submitterId", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<spark_session::JobType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<spark_session::Result>,
+    #[serde(rename = "schedulerInfo", default, skip_serializing_if = "Option::is_none")]
+    pub scheduler_info: Option<SparkScheduler>,
+    #[serde(rename = "pluginInfo", default, skip_serializing_if = "Option::is_none")]
+    pub plugin_info: Option<SparkServicePlugin>,
+    #[serde(rename = "errorInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_info: Vec<SparkServiceError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub id: i32,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appInfo", default, skip_serializing_if = "Option::is_none")]
+    pub app_info: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub log: Vec<String>,
+}
+pub mod spark_session {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum JobType {
+        SparkBatch,
+        SparkSession,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        Uncertain,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSessionState {
+    #[serde(rename = "notStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub not_started_at: Option<String>,
+    #[serde(rename = "startingAt", default, skip_serializing_if = "Option::is_none")]
+    pub starting_at: Option<String>,
+    #[serde(rename = "idleAt", default, skip_serializing_if = "Option::is_none")]
+    pub idle_at: Option<String>,
+    #[serde(rename = "deadAt", default, skip_serializing_if = "Option::is_none")]
+    pub dead_at: Option<String>,
+    #[serde(rename = "shuttingDownAt", default, skip_serializing_if = "Option::is_none")]
+    pub shutting_down_at: Option<String>,
+    #[serde(rename = "killedAt", default, skip_serializing_if = "Option::is_none")]
+    pub killed_at: Option<String>,
+    #[serde(rename = "recoveringAt", default, skip_serializing_if = "Option::is_none")]
+    pub recovering_at: Option<String>,
+    #[serde(rename = "busyAt", default, skip_serializing_if = "Option::is_none")]
+    pub busy_at: Option<String>,
+    #[serde(rename = "errorAt", default, skip_serializing_if = "Option::is_none")]
+    pub error_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+    #[serde(rename = "jobCreationRequest", default, skip_serializing_if = "Option::is_none")]
+    pub job_creation_request: Option<SparkRequest>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSessionOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub file: Option<String>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatementCollection {
+    pub total_statements: i32,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub statements: Vec<SparkStatement>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatement {
+    pub id: i32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<SparkStatementOutput>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatementOutput {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    pub execution_count: i32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ename: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub evalue: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub traceback: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatementOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<spark_statement_options::Kind>,
+}
+pub mod spark_statement_options {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        #[serde(rename = "spark")]
+        Spark,
+        #[serde(rename = "pyspark")]
+        Pyspark,
+        #[serde(rename = "dotnetspark")]
+        Dotnetspark,
+        #[serde(rename = "sql")]
+        Sql,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatementCancellationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msg: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_spark_2019_11_01_preview/operations.rs b/services/svc/synapse/src/package_spark_2019_11_01_preview/operations.rs
new file mode 100644
index 0000000000..a8afbb0663
--- /dev/null
+++ b/services/svc/synapse/src/package_spark_2019_11_01_preview/operations.rs
@@ -0,0 +1,825 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod spark_batch {
+    use crate::models::*;
+    pub async fn get_spark_batch_jobs(
+        operation_config: &crate::OperationConfig,
+        from: Option<i32>,
+        size: Option<i32>,
+        detailed: Option<bool>,
+    ) -> std::result::Result<SparkBatchJobCollection, get_spark_batch_jobs::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/batches", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_batch_jobs::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_batch_jobs::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(from) = from {
+            url.query_pairs_mut().append_pair("from", from.to_string().as_str());
+        }
+        if let Some(size) = size {
+            url.query_pairs_mut().append_pair("size", size.to_string().as_str());
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_batch_jobs::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_batch_jobs::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJobCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_batch_jobs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_batch_jobs::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_batch_jobs {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_spark_batch_job(
+        operation_config: &crate::OperationConfig,
+        detailed: Option<bool>,
+        spark_batch_job_options: &SparkBatchJobOptions,
+    ) -> std::result::Result<SparkBatchJob, create_spark_batch_job::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/batches", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(create_spark_batch_job::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_spark_batch_job::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(spark_batch_job_options).map_err(create_spark_batch_job::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_spark_batch_job::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_spark_batch_job::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_spark_batch_job::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_spark_batch_job::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_spark_batch_job {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_batch_job(
+        operation_config: &crate::OperationConfig,
+        batch_id: i32,
+        detailed: Option<bool>,
+    ) -> std::result::Result<SparkBatchJob, get_spark_batch_job::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/batches/{}", operation_config.base_path(), batch_id);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_batch_job::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_batch_job::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_batch_job::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_batch_job::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_batch_job::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_batch_job::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_batch_job {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_spark_batch_job(
+        operation_config: &crate::OperationConfig,
+        batch_id: i32,
+    ) -> std::result::Result<(), cancel_spark_batch_job::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/batches/{}", operation_config.base_path(), batch_id);
+        let mut url = url::Url::parse(url_str).map_err(cancel_spark_batch_job::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_spark_batch_job::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(cancel_spark_batch_job::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_spark_batch_job::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel_spark_batch_job::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel_spark_batch_job {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod spark_session {
+    use crate::models::*;
+    pub async fn get_spark_sessions(
+        operation_config: &crate::OperationConfig,
+        from: Option<i32>,
+        size: Option<i32>,
+        detailed: Option<bool>,
+    ) -> std::result::Result<SparkSessionCollection, get_spark_sessions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sessions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_sessions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_sessions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(from) = from {
+            url.query_pairs_mut().append_pair("from", from.to_string().as_str());
+        }
+        if let Some(size) = size {
+            url.query_pairs_mut().append_pair("size", size.to_string().as_str());
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_sessions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_sessions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkSessionCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_sessions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_sessions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_sessions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_spark_session(
+        operation_config: &crate::OperationConfig,
+        detailed: Option<bool>,
+        spark_session_options: &SparkSessionOptions,
+    ) -> std::result::Result<SparkSession, create_spark_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sessions", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(create_spark_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_spark_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(spark_session_options).map_err(create_spark_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_spark_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_spark_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkSession = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_spark_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_spark_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_spark_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_session(
+        operation_config: &crate::OperationConfig,
+        session_id: i32,
+        detailed: Option<bool>,
+    ) -> std::result::Result<SparkSession, get_spark_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sessions/{}", operation_config.base_path(), session_id);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkSession = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_spark_session(
+        operation_config: &crate::OperationConfig,
+        session_id: i32,
+    ) -> std::result::Result<(), cancel_spark_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sessions/{}", operation_config.base_path(), session_id);
+        let mut url = url::Url::parse(url_str).map_err(cancel_spark_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_spark_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel_spark_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_spark_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel_spark_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel_spark_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn reset_spark_session_timeout(
+        operation_config: &crate::OperationConfig,
+        session_id: i32,
+    ) -> std::result::Result<(), reset_spark_session_timeout::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sessions/{}/reset-timeout", operation_config.base_path(), session_id);
+        let mut url = url::Url::parse(url_str).map_err(reset_spark_session_timeout::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(reset_spark_session_timeout::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(reset_spark_session_timeout::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(reset_spark_session_timeout::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(reset_spark_session_timeout::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod reset_spark_session_timeout {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_statements(
+        operation_config: &crate::OperationConfig,
+        session_id: i32,
+    ) -> std::result::Result<SparkStatementCollection, get_spark_statements::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sessions/{}/statements", operation_config.base_path(), session_id);
+        let mut url = url::Url::parse(url_str).map_err(get_spark_statements::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_statements::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_statements::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_statements::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkStatementCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_statements::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_statements::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_statements {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_spark_statement(
+        operation_config: &crate::OperationConfig,
+        session_id: i32,
+        spark_statement_options: &SparkStatementOptions,
+    ) -> std::result::Result<SparkStatement, create_spark_statement::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/sessions/{}/statements", operation_config.base_path(), session_id);
+        let mut url = url::Url::parse(url_str).map_err(create_spark_statement::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_spark_statement::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(spark_statement_options).map_err(create_spark_statement::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_spark_statement::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_spark_statement::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkStatement = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_spark_statement::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_spark_statement::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_spark_statement {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_statement(
+        operation_config: &crate::OperationConfig,
+        session_id: i32,
+        statement_id: i32,
+    ) -> std::result::Result<SparkStatement, get_spark_statement::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sessions/{}/statements/{}",
+            operation_config.base_path(),
+            session_id,
+            statement_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_spark_statement::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_statement::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_statement::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_statement::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkStatement = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_statement::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_statement::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_statement {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_spark_statement(
+        operation_config: &crate::OperationConfig,
+        session_id: i32,
+        statement_id: i32,
+    ) -> std::result::Result<SparkStatementCancellationResult, cancel_spark_statement::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/sessions/{}/statements/{}/cancel",
+            operation_config.base_path(),
+            session_id,
+            statement_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_spark_statement::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_spark_statement::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(cancel_spark_statement::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_spark_statement::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkStatementCancellationResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_spark_statement::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel_spark_statement::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel_spark_statement {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_spark_2020_12_01/mod.rs b/services/svc/synapse/src/package_spark_2020_12_01/mod.rs
new file mode 100644
index 0000000000..295814b1a2
--- /dev/null
+++ b/services/svc/synapse/src/package_spark_2020_12_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-12-01";
diff --git a/services/svc/synapse/src/package_spark_2020_12_01/models.rs b/services/svc/synapse/src/package_spark_2020_12_01/models.rs
new file mode 100644
index 0000000000..2623359b2d
--- /dev/null
+++ b/services/svc/synapse/src/package_spark_2020_12_01/models.rs
@@ -0,0 +1,461 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobCollection {
+    pub from: i32,
+    pub total: i32,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sessions: Vec<SparkBatchJob>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJob {
+    #[serde(rename = "livyInfo", default, skip_serializing_if = "Option::is_none")]
+    pub livy_info: Option<SparkBatchJobState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "workspaceName", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_name: Option<String>,
+    #[serde(rename = "sparkPoolName", default, skip_serializing_if = "Option::is_none")]
+    pub spark_pool_name: Option<String>,
+    #[serde(rename = "submitterName", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_name: Option<String>,
+    #[serde(rename = "submitterId", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<spark_batch_job::JobType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<spark_batch_job::Result>,
+    #[serde(rename = "schedulerInfo", default, skip_serializing_if = "Option::is_none")]
+    pub scheduler_info: Option<SparkScheduler>,
+    #[serde(rename = "pluginInfo", default, skip_serializing_if = "Option::is_none")]
+    pub plugin_info: Option<SparkServicePlugin>,
+    #[serde(rename = "errorInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_info: Vec<SparkServiceError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub id: i32,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appInfo", default, skip_serializing_if = "Option::is_none")]
+    pub app_info: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<spark_batch_job::State>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub log: Vec<String>,
+}
+pub mod spark_batch_job {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum JobType {
+        SparkBatch,
+        SparkSession,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        Uncertain,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        #[serde(rename = "not_started")]
+        NotStarted,
+        #[serde(rename = "starting")]
+        Starting,
+        #[serde(rename = "idle")]
+        Idle,
+        #[serde(rename = "busy")]
+        Busy,
+        #[serde(rename = "shutting_down")]
+        ShuttingDown,
+        #[serde(rename = "error")]
+        Error,
+        #[serde(rename = "dead")]
+        Dead,
+        #[serde(rename = "killed")]
+        Killed,
+        #[serde(rename = "success")]
+        Success,
+        #[serde(rename = "running")]
+        Running,
+        #[serde(rename = "recovering")]
+        Recovering,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobState {
+    #[serde(rename = "notStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub not_started_at: Option<String>,
+    #[serde(rename = "startingAt", default, skip_serializing_if = "Option::is_none")]
+    pub starting_at: Option<String>,
+    #[serde(rename = "runningAt", default, skip_serializing_if = "Option::is_none")]
+    pub running_at: Option<String>,
+    #[serde(rename = "deadAt", default, skip_serializing_if = "Option::is_none")]
+    pub dead_at: Option<String>,
+    #[serde(rename = "successAt", default, skip_serializing_if = "Option::is_none")]
+    pub success_at: Option<String>,
+    #[serde(rename = "killedAt", default, skip_serializing_if = "Option::is_none")]
+    pub killed_at: Option<String>,
+    #[serde(rename = "recoveringAt", default, skip_serializing_if = "Option::is_none")]
+    pub recovering_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+    #[serde(rename = "jobCreationRequest", default, skip_serializing_if = "Option::is_none")]
+    pub job_creation_request: Option<SparkRequest>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkScheduler {
+    #[serde(rename = "submittedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submitted_at: Option<String>,
+    #[serde(rename = "scheduledAt", default, skip_serializing_if = "Option::is_none")]
+    pub scheduled_at: Option<String>,
+    #[serde(rename = "endedAt", default, skip_serializing_if = "Option::is_none")]
+    pub ended_at: Option<String>,
+    #[serde(rename = "cancellationRequestedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cancellation_requested_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_scheduler::CurrentState>,
+}
+pub mod spark_scheduler {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Queued,
+        Scheduled,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServicePlugin {
+    #[serde(rename = "preparationStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub preparation_started_at: Option<String>,
+    #[serde(rename = "resourceAcquisitionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub resource_acquisition_started_at: Option<String>,
+    #[serde(rename = "submissionStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub submission_started_at: Option<String>,
+    #[serde(rename = "monitoringStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub monitoring_started_at: Option<String>,
+    #[serde(rename = "cleanupStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub cleanup_started_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<spark_service_plugin::CurrentState>,
+}
+pub mod spark_service_plugin {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum CurrentState {
+        Preparation,
+        ResourceAcquisition,
+        Queued,
+        Submission,
+        Monitoring,
+        Cleanup,
+        Ended,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkServiceError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
+    pub error_code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<spark_service_error::Source>,
+}
+pub mod spark_service_error {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Source {
+        System,
+        User,
+        Unknown,
+        Dependency,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub file: Option<String>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkBatchJobOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    pub name: String,
+    pub file: String,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSessionCollection {
+    pub from: i32,
+    pub total: i32,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sessions: Vec<SparkSession>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSession {
+    #[serde(rename = "livyInfo", default, skip_serializing_if = "Option::is_none")]
+    pub livy_info: Option<SparkSessionState>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "workspaceName", default, skip_serializing_if = "Option::is_none")]
+    pub workspace_name: Option<String>,
+    #[serde(rename = "sparkPoolName", default, skip_serializing_if = "Option::is_none")]
+    pub spark_pool_name: Option<String>,
+    #[serde(rename = "submitterName", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_name: Option<String>,
+    #[serde(rename = "submitterId", default, skip_serializing_if = "Option::is_none")]
+    pub submitter_id: Option<String>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    #[serde(rename = "jobType", default, skip_serializing_if = "Option::is_none")]
+    pub job_type: Option<spark_session::JobType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub result: Option<spark_session::Result>,
+    #[serde(rename = "schedulerInfo", default, skip_serializing_if = "Option::is_none")]
+    pub scheduler_info: Option<SparkScheduler>,
+    #[serde(rename = "pluginInfo", default, skip_serializing_if = "Option::is_none")]
+    pub plugin_info: Option<SparkServicePlugin>,
+    #[serde(rename = "errorInfo", default, skip_serializing_if = "Vec::is_empty")]
+    pub error_info: Vec<SparkServiceError>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    pub id: i32,
+    #[serde(rename = "appId", default, skip_serializing_if = "Option::is_none")]
+    pub app_id: Option<String>,
+    #[serde(rename = "appInfo", default, skip_serializing_if = "Option::is_none")]
+    pub app_info: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<spark_session::State>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub log: Vec<String>,
+}
+pub mod spark_session {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum JobType {
+        SparkBatch,
+        SparkSession,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Result {
+        Uncertain,
+        Succeeded,
+        Failed,
+        Cancelled,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        #[serde(rename = "not_started")]
+        NotStarted,
+        #[serde(rename = "starting")]
+        Starting,
+        #[serde(rename = "idle")]
+        Idle,
+        #[serde(rename = "busy")]
+        Busy,
+        #[serde(rename = "shutting_down")]
+        ShuttingDown,
+        #[serde(rename = "error")]
+        Error,
+        #[serde(rename = "dead")]
+        Dead,
+        #[serde(rename = "killed")]
+        Killed,
+        #[serde(rename = "success")]
+        Success,
+        #[serde(rename = "running")]
+        Running,
+        #[serde(rename = "recovering")]
+        Recovering,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSessionState {
+    #[serde(rename = "notStartedAt", default, skip_serializing_if = "Option::is_none")]
+    pub not_started_at: Option<String>,
+    #[serde(rename = "startingAt", default, skip_serializing_if = "Option::is_none")]
+    pub starting_at: Option<String>,
+    #[serde(rename = "idleAt", default, skip_serializing_if = "Option::is_none")]
+    pub idle_at: Option<String>,
+    #[serde(rename = "deadAt", default, skip_serializing_if = "Option::is_none")]
+    pub dead_at: Option<String>,
+    #[serde(rename = "shuttingDownAt", default, skip_serializing_if = "Option::is_none")]
+    pub shutting_down_at: Option<String>,
+    #[serde(rename = "killedAt", default, skip_serializing_if = "Option::is_none")]
+    pub killed_at: Option<String>,
+    #[serde(rename = "recoveringAt", default, skip_serializing_if = "Option::is_none")]
+    pub recovering_at: Option<String>,
+    #[serde(rename = "busyAt", default, skip_serializing_if = "Option::is_none")]
+    pub busy_at: Option<String>,
+    #[serde(rename = "errorAt", default, skip_serializing_if = "Option::is_none")]
+    pub error_at: Option<String>,
+    #[serde(rename = "currentState", default, skip_serializing_if = "Option::is_none")]
+    pub current_state: Option<String>,
+    #[serde(rename = "jobCreationRequest", default, skip_serializing_if = "Option::is_none")]
+    pub job_creation_request: Option<SparkRequest>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkSessionOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tags: Option<serde_json::Value>,
+    #[serde(rename = "artifactId", default, skip_serializing_if = "Option::is_none")]
+    pub artifact_id: Option<String>,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub file: Option<String>,
+    #[serde(rename = "className", default, skip_serializing_if = "Option::is_none")]
+    pub class_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub jars: Vec<String>,
+    #[serde(rename = "pyFiles", default, skip_serializing_if = "Vec::is_empty")]
+    pub py_files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub files: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub archives: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub conf: Option<serde_json::Value>,
+    #[serde(rename = "driverMemory", default, skip_serializing_if = "Option::is_none")]
+    pub driver_memory: Option<String>,
+    #[serde(rename = "driverCores", default, skip_serializing_if = "Option::is_none")]
+    pub driver_cores: Option<i32>,
+    #[serde(rename = "executorMemory", default, skip_serializing_if = "Option::is_none")]
+    pub executor_memory: Option<String>,
+    #[serde(rename = "executorCores", default, skip_serializing_if = "Option::is_none")]
+    pub executor_cores: Option<i32>,
+    #[serde(rename = "numExecutors", default, skip_serializing_if = "Option::is_none")]
+    pub num_executors: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatementCollection {
+    pub total_statements: i32,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub statements: Vec<SparkStatement>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatement {
+    pub id: i32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<spark_statement::State>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output: Option<SparkStatementOutput>,
+}
+pub mod spark_statement {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        #[serde(rename = "waiting")]
+        Waiting,
+        #[serde(rename = "running")]
+        Running,
+        #[serde(rename = "available")]
+        Available,
+        #[serde(rename = "error")]
+        Error,
+        #[serde(rename = "cancelling")]
+        Cancelling,
+        #[serde(rename = "cancelled")]
+        Cancelled,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatementOutput {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    pub execution_count: i32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ename: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub evalue: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub traceback: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatementOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<spark_statement_options::Kind>,
+}
+pub mod spark_statement_options {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        #[serde(rename = "spark")]
+        Spark,
+        #[serde(rename = "pyspark")]
+        Pyspark,
+        #[serde(rename = "dotnetspark")]
+        Dotnetspark,
+        #[serde(rename = "sql")]
+        Sql,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SparkStatementCancellationResult {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub msg: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_spark_2020_12_01/operations.rs b/services/svc/synapse/src/package_spark_2020_12_01/operations.rs
new file mode 100644
index 0000000000..1a30a464aa
--- /dev/null
+++ b/services/svc/synapse/src/package_spark_2020_12_01/operations.rs
@@ -0,0 +1,917 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod spark_batch {
+    use crate::models::*;
+    pub async fn get_spark_batch_jobs(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        from: Option<i32>,
+        size: Option<i32>,
+        detailed: Option<bool>,
+    ) -> std::result::Result<SparkBatchJobCollection, get_spark_batch_jobs::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/batches",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_spark_batch_jobs::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_batch_jobs::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(from) = from {
+            url.query_pairs_mut().append_pair("from", from.to_string().as_str());
+        }
+        if let Some(size) = size {
+            url.query_pairs_mut().append_pair("size", size.to_string().as_str());
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_batch_jobs::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_batch_jobs::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJobCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_batch_jobs::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_batch_jobs::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_batch_jobs {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_spark_batch_job(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        detailed: Option<bool>,
+        spark_batch_job_options: &SparkBatchJobOptions,
+    ) -> std::result::Result<SparkBatchJob, create_spark_batch_job::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/batches",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_spark_batch_job::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_spark_batch_job::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(spark_batch_job_options).map_err(create_spark_batch_job::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_spark_batch_job::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_spark_batch_job::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_spark_batch_job::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_spark_batch_job::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_spark_batch_job {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_batch_job(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        batch_id: i32,
+        detailed: Option<bool>,
+    ) -> std::result::Result<SparkBatchJob, get_spark_batch_job::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/batches/{}",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            batch_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_spark_batch_job::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_batch_job::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_batch_job::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_batch_job::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkBatchJob = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_batch_job::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_batch_job::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_batch_job {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_spark_batch_job(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        batch_id: i32,
+    ) -> std::result::Result<(), cancel_spark_batch_job::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/batches/{}",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            batch_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_spark_batch_job::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_spark_batch_job::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(cancel_spark_batch_job::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_spark_batch_job::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel_spark_batch_job::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel_spark_batch_job {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod spark_session {
+    use crate::models::*;
+    pub async fn get_spark_sessions(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        from: Option<i32>,
+        size: Option<i32>,
+        detailed: Option<bool>,
+    ) -> std::result::Result<SparkSessionCollection, get_spark_sessions::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_spark_sessions::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_sessions::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(from) = from {
+            url.query_pairs_mut().append_pair("from", from.to_string().as_str());
+        }
+        if let Some(size) = size {
+            url.query_pairs_mut().append_pair("size", size.to_string().as_str());
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_sessions::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_sessions::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkSessionCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_sessions::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_sessions::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_sessions {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_spark_session(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        detailed: Option<bool>,
+        spark_session_options: &SparkSessionOptions,
+    ) -> std::result::Result<SparkSession, create_spark_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_spark_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_spark_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(spark_session_options).map_err(create_spark_session::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create_spark_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_spark_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkSession = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_spark_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_spark_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_spark_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_session(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        session_id: i32,
+        detailed: Option<bool>,
+    ) -> std::result::Result<SparkSession, get_spark_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions/{}",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            session_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_spark_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        if let Some(detailed) = detailed {
+            url.query_pairs_mut().append_pair("detailed", detailed.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkSession = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_session::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_spark_session(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        session_id: i32,
+    ) -> std::result::Result<(), cancel_spark_session::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions/{}",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            session_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_spark_session::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_spark_session::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(cancel_spark_session::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_spark_session::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel_spark_session::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel_spark_session {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn reset_spark_session_timeout(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        session_id: i32,
+    ) -> std::result::Result<(), reset_spark_session_timeout::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions/{}/reset-timeout",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            session_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(reset_spark_session_timeout::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(reset_spark_session_timeout::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(reset_spark_session_timeout::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(reset_spark_session_timeout::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(reset_spark_session_timeout::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod reset_spark_session_timeout {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_statements(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        session_id: i32,
+    ) -> std::result::Result<SparkStatementCollection, get_spark_statements::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions/{}/statements",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            session_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_spark_statements::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_statements::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_statements::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_statements::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkStatementCollection = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_statements::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_statements::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_statements {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create_spark_statement(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        session_id: i32,
+        spark_statement_options: &SparkStatementOptions,
+    ) -> std::result::Result<SparkStatement, create_spark_statement::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions/{}/statements",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            session_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(create_spark_statement::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create_spark_statement::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = azure_core::to_json(spark_statement_options).map_err(create_spark_statement::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(create_spark_statement::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(create_spark_statement::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkStatement = serde_json::from_slice(rsp_body)
+                    .map_err(|source| create_spark_statement::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create_spark_statement::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create_spark_statement {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_spark_statement(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        session_id: i32,
+        statement_id: i32,
+    ) -> std::result::Result<SparkStatement, get_spark_statement::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions/{}/statements/{}",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            session_id,
+            statement_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(get_spark_statement::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_spark_statement::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_spark_statement::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_spark_statement::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkStatement = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_spark_statement::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get_spark_statement::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get_spark_statement {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn cancel_spark_statement(
+        operation_config: &crate::OperationConfig,
+        livy_api_version: &str,
+        spark_pool_name: &str,
+        session_id: i32,
+        statement_id: i32,
+    ) -> std::result::Result<SparkStatementCancellationResult, cancel_spark_statement::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/livyApi/versions/{}/sparkPools/{}/sessions/{}/statements/{}/cancel",
+            operation_config.base_path(),
+            livy_api_version,
+            spark_pool_name,
+            session_id,
+            statement_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(cancel_spark_statement::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(cancel_spark_statement::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(cancel_spark_statement::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(cancel_spark_statement::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SparkStatementCancellationResult = serde_json::from_slice(rsp_body)
+                    .map_err(|source| cancel_spark_statement::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(cancel_spark_statement::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod cancel_spark_statement {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_vnet_2019_06_01_preview/mod.rs b/services/svc/synapse/src/package_vnet_2019_06_01_preview/mod.rs
new file mode 100644
index 0000000000..3a33dc519c
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2019_06_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2019-06-01-preview";
diff --git a/services/svc/synapse/src/package_vnet_2019_06_01_preview/models.rs b/services/svc/synapse/src/package_vnet_2019_06_01_preview/models.rs
new file mode 100644
index 0000000000..e64373cc68
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2019_06_01_preview/models.rs
@@ -0,0 +1,44 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointListResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ManagedPrivateEndpoint>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpoint {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<ManagedPrivateEndpointProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointProperties {
+    #[serde(rename = "privateLinkResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub private_link_resource_id: Option<String>,
+    #[serde(rename = "groupId", default, skip_serializing_if = "Option::is_none")]
+    pub group_id: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "connectionState", default, skip_serializing_if = "Option::is_none")]
+    pub connection_state: Option<ManagedPrivateEndpointConnectionState>,
+    #[serde(rename = "isReserved", default, skip_serializing_if = "Option::is_none")]
+    pub is_reserved: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointConnectionState {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "actionsRequired", default, skip_serializing_if = "Option::is_none")]
+    pub actions_required: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_vnet_2019_06_01_preview/operations.rs b/services/svc/synapse/src/package_vnet_2019_06_01_preview/operations.rs
new file mode 100644
index 0000000000..70254cc737
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2019_06_01_preview/operations.rs
@@ -0,0 +1,260 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod managed_private_endpoints {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+    ) -> std::result::Result<ManagedPrivateEndpoint, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpoint =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+        managed_private_endpoint: &ManagedPrivateEndpoint,
+    ) -> std::result::Result<ManagedPrivateEndpoint, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(managed_private_endpoint).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpoint =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(delete::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(delete::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+    ) -> std::result::Result<ManagedPrivateEndpointListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints",
+            operation_config.base_path(),
+            managed_virtual_network_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpointListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_vnet_2020_12_01/mod.rs b/services/svc/synapse/src/package_vnet_2020_12_01/mod.rs
new file mode 100644
index 0000000000..295814b1a2
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2020_12_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-12-01";
diff --git a/services/svc/synapse/src/package_vnet_2020_12_01/models.rs b/services/svc/synapse/src/package_vnet_2020_12_01/models.rs
new file mode 100644
index 0000000000..62bd00ff8c
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2020_12_01/models.rs
@@ -0,0 +1,50 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointListResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ManagedPrivateEndpoint>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpoint {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<ManagedPrivateEndpointProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "privateLinkResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub private_link_resource_id: Option<String>,
+    #[serde(rename = "groupId", default, skip_serializing_if = "Option::is_none")]
+    pub group_id: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "connectionState", default, skip_serializing_if = "Option::is_none")]
+    pub connection_state: Option<ManagedPrivateEndpointConnectionState>,
+    #[serde(rename = "isReserved", default, skip_serializing_if = "Option::is_none")]
+    pub is_reserved: Option<bool>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub fqdns: Vec<String>,
+    #[serde(rename = "isCompliant", default, skip_serializing_if = "Option::is_none")]
+    pub is_compliant: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointConnectionState {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "actionsRequired", default, skip_serializing_if = "Option::is_none")]
+    pub actions_required: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_vnet_2020_12_01/operations.rs b/services/svc/synapse/src/package_vnet_2020_12_01/operations.rs
new file mode 100644
index 0000000000..70254cc737
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2020_12_01/operations.rs
@@ -0,0 +1,260 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod managed_private_endpoints {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+    ) -> std::result::Result<ManagedPrivateEndpoint, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpoint =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+        managed_private_endpoint: &ManagedPrivateEndpoint,
+    ) -> std::result::Result<ManagedPrivateEndpoint, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(managed_private_endpoint).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpoint =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(delete::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(delete::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+    ) -> std::result::Result<ManagedPrivateEndpointListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints",
+            operation_config.base_path(),
+            managed_virtual_network_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpointListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/synapse/src/package_vnet_2021_06_01_preview/mod.rs b/services/svc/synapse/src/package_vnet_2021_06_01_preview/mod.rs
new file mode 100644
index 0000000000..ed72a17404
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2021_06_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-06-01-preview";
diff --git a/services/svc/synapse/src/package_vnet_2021_06_01_preview/models.rs b/services/svc/synapse/src/package_vnet_2021_06_01_preview/models.rs
new file mode 100644
index 0000000000..62bd00ff8c
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2021_06_01_preview/models.rs
@@ -0,0 +1,50 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointListResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<ManagedPrivateEndpoint>,
+    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
+    pub next_link: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpoint {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<ManagedPrivateEndpointProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "privateLinkResourceId", default, skip_serializing_if = "Option::is_none")]
+    pub private_link_resource_id: Option<String>,
+    #[serde(rename = "groupId", default, skip_serializing_if = "Option::is_none")]
+    pub group_id: Option<String>,
+    #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
+    pub provisioning_state: Option<String>,
+    #[serde(rename = "connectionState", default, skip_serializing_if = "Option::is_none")]
+    pub connection_state: Option<ManagedPrivateEndpointConnectionState>,
+    #[serde(rename = "isReserved", default, skip_serializing_if = "Option::is_none")]
+    pub is_reserved: Option<bool>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub fqdns: Vec<String>,
+    #[serde(rename = "isCompliant", default, skip_serializing_if = "Option::is_none")]
+    pub is_compliant: Option<bool>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ManagedPrivateEndpointConnectionState {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub status: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "actionsRequired", default, skip_serializing_if = "Option::is_none")]
+    pub actions_required: Option<String>,
+}
diff --git a/services/svc/synapse/src/package_vnet_2021_06_01_preview/operations.rs b/services/svc/synapse/src/package_vnet_2021_06_01_preview/operations.rs
new file mode 100644
index 0000000000..70254cc737
--- /dev/null
+++ b/services/svc/synapse/src/package_vnet_2021_06_01_preview/operations.rs
@@ -0,0 +1,260 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod managed_private_endpoints {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+    ) -> std::result::Result<ManagedPrivateEndpoint, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpoint =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(get::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn create(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+        managed_private_endpoint: &ManagedPrivateEndpoint,
+    ) -> std::result::Result<ManagedPrivateEndpoint, create::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(create::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(create::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(managed_private_endpoint).map_err(create::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(create::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(create::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpoint =
+                    serde_json::from_slice(rsp_body).map_err(|source| create::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(create::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod create {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn delete(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+        managed_private_endpoint_name: &str,
+    ) -> std::result::Result<delete::Response, delete::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints/{}",
+            operation_config.base_path(),
+            managed_virtual_network_name,
+            managed_private_endpoint_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(delete::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(delete::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(delete::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(delete::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(delete::Response::Accepted202),
+            http::StatusCode::NO_CONTENT => Ok(delete::Response::NoContent204),
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(delete::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod delete {
+        use crate::{models, models::*};
+        #[derive(Debug)]
+        pub enum Response {
+            Accepted202,
+            NoContent204,
+        }
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        managed_virtual_network_name: &str,
+    ) -> std::result::Result<ManagedPrivateEndpointListResponse, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/managedVirtualNetworks/{}/managedPrivateEndpoints",
+            operation_config.base_path(),
+            managed_virtual_network_name
+        );
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ManagedPrivateEndpointListResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                Err(list::Error::UnexpectedResponse {
+                    status_code,
+                    body: rsp_body.clone(),
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Unexpected HTTP status code {}", status_code)]
+            UnexpectedResponse { status_code: http::StatusCode, body: bytes::Bytes },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/timeseriesinsights/Cargo.toml b/services/svc/timeseriesinsights/Cargo.toml
new file mode 100644
index 0000000000..1f34b72640
--- /dev/null
+++ b/services/svc/timeseriesinsights/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_timeseriesinsights"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2020-07-31"]
+"package-2020-07-31" = []
diff --git a/services/svc/timeseriesinsights/src/lib.rs b/services/svc/timeseriesinsights/src/lib.rs
new file mode 100644
index 0000000000..0be329b432
--- /dev/null
+++ b/services/svc/timeseriesinsights/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2020-07-31")]
+mod package_2020_07_31;
+use azure_core::setters;
+#[cfg(feature = "package-2020-07-31")]
+pub use package_2020_07_31::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/timeseriesinsights/src/package_2020_07_31/mod.rs b/services/svc/timeseriesinsights/src/package_2020_07_31/mod.rs
new file mode 100644
index 0000000000..20cbe7e85e
--- /dev/null
+++ b/services/svc/timeseriesinsights/src/package_2020_07_31/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2020-07-31";
diff --git a/services/svc/timeseriesinsights/src/package_2020_07_31/models.rs b/services/svc/timeseriesinsights/src/package_2020_07_31/models.rs
new file mode 100644
index 0000000000..c528db51f0
--- /dev/null
+++ b/services/svc/timeseriesinsights/src/package_2020_07_31/models.rs
@@ -0,0 +1,559 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AvailabilityResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub availability: Option<Availability>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Availability {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub range: Option<DateTimeRange>,
+    #[serde(rename = "intervalSize", default, skip_serializing_if = "Option::is_none")]
+    pub interval_size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub distribution: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetEventSchemaRequest {
+    #[serde(rename = "searchSpan")]
+    pub search_span: DateTimeRange,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventSchema {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub properties: Vec<EventProperty>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryRequest {
+    #[serde(rename = "getEvents", default, skip_serializing_if = "Option::is_none")]
+    pub get_events: Option<GetEvents>,
+    #[serde(rename = "getSeries", default, skip_serializing_if = "Option::is_none")]
+    pub get_series: Option<GetSeries>,
+    #[serde(rename = "aggregateSeries", default, skip_serializing_if = "Option::is_none")]
+    pub aggregate_series: Option<AggregateSeries>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetEvents {
+    #[serde(rename = "timeSeriesId")]
+    pub time_series_id: TimeSeriesId,
+    #[serde(rename = "searchSpan")]
+    pub search_span: DateTimeRange,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<Tsx>,
+    #[serde(rename = "projectedProperties", default, skip_serializing_if = "Vec::is_empty")]
+    pub projected_properties: Vec<EventProperty>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub take: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetSeries {
+    #[serde(rename = "timeSeriesId")]
+    pub time_series_id: TimeSeriesId,
+    #[serde(rename = "searchSpan")]
+    pub search_span: DateTimeRange,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<Tsx>,
+    #[serde(rename = "projectedVariables", default, skip_serializing_if = "Vec::is_empty")]
+    pub projected_variables: Vec<String>,
+    #[serde(rename = "inlineVariables", default, skip_serializing_if = "Option::is_none")]
+    pub inline_variables: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub take: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AggregateSeries {
+    #[serde(rename = "timeSeriesId")]
+    pub time_series_id: TimeSeriesId,
+    #[serde(rename = "searchSpan")]
+    pub search_span: DateTimeRange,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<Tsx>,
+    pub interval: String,
+    #[serde(rename = "projectedVariables", default, skip_serializing_if = "Vec::is_empty")]
+    pub projected_variables: Vec<String>,
+    #[serde(rename = "inlineVariables", default, skip_serializing_if = "Option::is_none")]
+    pub inline_variables: Option<serde_json::Value>,
+}
+pub type TimeSeriesId = Vec<serde_json::Value>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Tsx {
+    pub tsx: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Interpolation {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<interpolation::Kind>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub boundary: Option<interpolation::Boundary>,
+}
+pub mod interpolation {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        Linear,
+        Step,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Boundary {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub span: Option<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct DateTimeRange {
+    pub from: String,
+    pub to: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NumericVariable {
+    #[serde(flatten)]
+    pub variable: Variable,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AggregateVariable {
+    #[serde(flatten)]
+    pub variable: Variable,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CategoricalVariable {
+    #[serde(flatten)]
+    pub variable: Variable,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesAggregateCategory {
+    pub label: String,
+    pub values: Vec<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesDefaultCategory {
+    pub label: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Variable {
+    pub kind: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub filter: Option<Tsx>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct QueryResultPage {
+    #[serde(flatten)]
+    pub paged_response: PagedResponse,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PropertyValues {
+    #[serde(flatten)]
+    pub event_property: EventProperty,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetInstancesPage {
+    #[serde(flatten)]
+    pub paged_response: PagedResponse,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesInstance {
+    #[serde(rename = "timeSeriesId")]
+    pub time_series_id: TimeSeriesId,
+    #[serde(rename = "typeId")]
+    pub type_id: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "hierarchyIds", default, skip_serializing_if = "Vec::is_empty")]
+    pub hierarchy_ids: Vec<String>,
+    #[serde(rename = "instanceFields", default, skip_serializing_if = "Option::is_none")]
+    pub instance_fields: Option<serde_json::Value>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstancesBatchRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub get: Option<InstancesRequestBatchGetOrDelete>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub put: Vec<TimeSeriesInstance>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub update: Vec<TimeSeriesInstance>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub delete: Option<InstancesRequestBatchGetOrDelete>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstancesRequestBatchGetOrDelete {
+    #[serde(rename = "timeSeriesIds", default, skip_serializing_if = "Vec::is_empty")]
+    pub time_series_ids: Vec<TimeSeriesId>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub names: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstancesBatchResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub get: Vec<InstanceOrError>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub put: Vec<InstanceOrError>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub update: Vec<InstanceOrError>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub delete: Vec<TsiErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstanceOrError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub instance: Option<TimeSeriesInstance>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<TsiErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetTypesPage {
+    #[serde(flatten)]
+    pub paged_response: PagedResponse,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesType {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub variables: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypesBatchRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub get: Option<TypesRequestBatchGetOrDelete>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub put: Vec<TimeSeriesType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub delete: Option<TypesRequestBatchGetOrDelete>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypesRequestBatchGetOrDelete {
+    #[serde(rename = "typeIds", default, skip_serializing_if = "Vec::is_empty")]
+    pub type_ids: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub names: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TypesBatchResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub get: Vec<TimeSeriesTypeOrError>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub put: Vec<TimeSeriesTypeOrError>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub delete: Vec<TsiErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesTypeOrError {
+    #[serde(rename = "timeSeriesType", default, skip_serializing_if = "Option::is_none")]
+    pub time_series_type: Option<TimeSeriesType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<TsiErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GetHierarchiesPage {
+    #[serde(flatten)]
+    pub paged_response: PagedResponse,
+    #[serde(flatten)]
+    pub serde_json_value: serde_json::Value,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesHierarchy {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub name: String,
+    pub source: time_series_hierarchy::Source,
+}
+pub mod time_series_hierarchy {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Source {
+        #[serde(rename = "instanceFieldNames", default, skip_serializing_if = "Vec::is_empty")]
+        pub instance_field_names: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HierarchiesBatchRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub get: Option<HierarchiesRequestBatchGetDelete>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub put: Vec<TimeSeriesHierarchy>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub delete: Option<HierarchiesRequestBatchGetDelete>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HierarchiesRequestBatchGetDelete {
+    #[serde(rename = "hierarchyIds", default, skip_serializing_if = "Vec::is_empty")]
+    pub hierarchy_ids: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub names: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HierarchiesBatchResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub get: Vec<TimeSeriesHierarchyOrError>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub put: Vec<TimeSeriesHierarchyOrError>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub delete: Vec<TsiErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesHierarchyOrError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub hierarchy: Option<TimeSeriesHierarchy>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<TsiErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ModelSettingsResponse {
+    #[serde(rename = "modelSettings", default, skip_serializing_if = "Option::is_none")]
+    pub model_settings: Option<TimeSeriesModelSettings>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesModelSettings {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "timeSeriesIdProperties", default, skip_serializing_if = "Option::is_none")]
+    pub time_series_id_properties: Option<TimeSeriesIdProperties>,
+    #[serde(rename = "defaultTypeId", default, skip_serializing_if = "Option::is_none")]
+    pub default_type_id: Option<String>,
+}
+pub type TimeSeriesIdProperties = Vec<TimeSeriesIdProperty>;
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TimeSeriesIdProperty {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<time_series_id_property::Type>,
+}
+pub mod time_series_id_property {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        String,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UpdateModelSettingsRequest {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "defaultTypeId", default, skip_serializing_if = "Option::is_none")]
+    pub default_type_id: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SearchInstancesRequest {
+    #[serde(rename = "searchString")]
+    pub search_string: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub path: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub instances: Option<SearchInstancesParameters>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub hierarchies: Option<SearchInstancesHierarchiesParameters>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SearchInstancesParameters {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sort: Option<InstancesSortParameter>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub highlights: Option<bool>,
+    #[serde(rename = "pageSize", default, skip_serializing_if = "Option::is_none")]
+    pub page_size: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstancesSortParameter {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub by: Option<instances_sort_parameter::By>,
+}
+pub mod instances_sort_parameter {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum By {
+        Rank,
+        DisplayName,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SearchInstancesHierarchiesParameters {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expand: Option<HierarchiesExpandParameter>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sort: Option<HierarchiesSortParameter>,
+    #[serde(rename = "pageSize", default, skip_serializing_if = "Option::is_none")]
+    pub page_size: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HierarchiesExpandParameter {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<hierarchies_expand_parameter::Kind>,
+}
+pub mod hierarchies_expand_parameter {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Kind {
+        UntilChildren,
+        OneLevel,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HierarchiesSortParameter {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub by: Option<hierarchies_sort_parameter::By>,
+}
+pub mod hierarchies_sort_parameter {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum By {
+        CumulativeInstanceCount,
+        Name,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SearchInstancesResponsePage {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub instances: Option<SearchInstancesResponse>,
+    #[serde(rename = "hierarchyNodes", default, skip_serializing_if = "Option::is_none")]
+    pub hierarchy_nodes: Option<SearchHierarchyNodesResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SearchInstancesResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub hits: Vec<InstanceHit>,
+    #[serde(rename = "hitCount", default, skip_serializing_if = "Option::is_none")]
+    pub hit_count: Option<i32>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SearchHierarchyNodesResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub hits: Vec<HierarchyHit>,
+    #[serde(rename = "hitCount", default, skip_serializing_if = "Option::is_none")]
+    pub hit_count: Option<i32>,
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstanceHit {
+    #[serde(rename = "timeSeriesId", default, skip_serializing_if = "Option::is_none")]
+    pub time_series_id: Option<TimeSeriesId>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "typeId", default, skip_serializing_if = "Option::is_none")]
+    pub type_id: Option<String>,
+    #[serde(rename = "hierarchyIds", default, skip_serializing_if = "Vec::is_empty")]
+    pub hierarchy_ids: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub highlights: Option<instance_hit::Highlights>,
+}
+pub mod instance_hit {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub struct Highlights {
+        #[serde(rename = "timeSeriesId", default, skip_serializing_if = "Vec::is_empty")]
+        pub time_series_id: Vec<String>,
+        #[serde(rename = "typeName", default, skip_serializing_if = "Option::is_none")]
+        pub type_name: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub name: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        pub description: Option<String>,
+        #[serde(rename = "hierarchyIds", default, skip_serializing_if = "Vec::is_empty")]
+        pub hierarchy_ids: Vec<String>,
+        #[serde(rename = "hierarchyNames", default, skip_serializing_if = "Vec::is_empty")]
+        pub hierarchy_names: Vec<String>,
+        #[serde(rename = "instanceFieldNames", default, skip_serializing_if = "Vec::is_empty")]
+        pub instance_field_names: Vec<String>,
+        #[serde(rename = "instanceFieldValues", default, skip_serializing_if = "Vec::is_empty")]
+        pub instance_field_values: Vec<String>,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HierarchyHit {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "cumulativeInstanceCount", default, skip_serializing_if = "Option::is_none")]
+    pub cumulative_instance_count: Option<i32>,
+    #[serde(rename = "hierarchyNodes", default, skip_serializing_if = "Option::is_none")]
+    pub hierarchy_nodes: Option<SearchHierarchyNodesResponse>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstancesSuggestRequest {
+    #[serde(rename = "searchString")]
+    pub search_string: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub take: Option<i32>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstancesSuggestResponse {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub suggestions: Vec<InstancesSearchStringSuggestion>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InstancesSearchStringSuggestion {
+    #[serde(rename = "searchString", default, skip_serializing_if = "Option::is_none")]
+    pub search_string: Option<String>,
+    #[serde(rename = "highlightedSearchString", default, skip_serializing_if = "Option::is_none")]
+    pub highlighted_search_string: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PagedResponse {
+    #[serde(rename = "continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EventProperty {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
+    pub type_: Option<PropertyType>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum PropertyType {
+    Bool,
+    DateTime,
+    Double,
+    String,
+    TimeSpan,
+    Long,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TsiError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<TsiErrorBody>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TsiErrorBody {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(rename = "innerError", default, skip_serializing_if = "Option::is_none")]
+    pub inner_error: Box<Option<TsiErrorBody>>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<TsiErrorDetails>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TsiErrorDetails {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+}
diff --git a/services/svc/timeseriesinsights/src/package_2020_07_31/operations.rs b/services/svc/timeseriesinsights/src/package_2020_07_31/operations.rs
new file mode 100644
index 0000000000..1415873d82
--- /dev/null
+++ b/services/svc/timeseriesinsights/src/package_2020_07_31/operations.rs
@@ -0,0 +1,978 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod query {
+    use crate::models::*;
+    pub async fn get_availability(
+        operation_config: &crate::OperationConfig,
+        store_type: Option<&str>,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<AvailabilityResponse, get_availability::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/availability", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_availability::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_availability::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(store_type) = store_type {
+            url.query_pairs_mut().append_pair("storeType", store_type);
+        }
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_availability::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_availability::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: AvailabilityResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_availability::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_availability::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_availability::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_availability {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn get_event_schema(
+        operation_config: &crate::OperationConfig,
+        store_type: Option<&str>,
+        parameters: &GetEventSchemaRequest,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<EventSchema, get_event_schema::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/eventSchema", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_event_schema::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_event_schema::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(store_type) = store_type {
+            url.query_pairs_mut().append_pair("storeType", store_type);
+        }
+        let req_body = azure_core::to_json(parameters).map_err(get_event_schema::Error::SerializeError)?;
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_event_schema::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_event_schema::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: EventSchema = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_schema::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError = serde_json::from_slice(rsp_body)
+                    .map_err(|source| get_event_schema::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get_event_schema::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get_event_schema {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute(
+        operation_config: &crate::OperationConfig,
+        store_type: Option<&str>,
+        x_ms_continuation: Option<&str>,
+        parameters: &QueryRequest,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<QueryResultPage, execute::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/query", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(execute::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(store_type) = store_type {
+            url.query_pairs_mut().append_pair("storeType", store_type);
+        }
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        let req_body = azure_core::to_json(parameters).map_err(execute::Error::SerializeError)?;
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: QueryResultPage =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod model_settings {
+    use crate::models::*;
+    pub async fn get(
+        operation_config: &crate::OperationConfig,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<ModelSettingsResponse, get::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/modelSettings", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(get::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ModelSettingsResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| get::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(get::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod get {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn update(
+        operation_config: &crate::OperationConfig,
+        parameters: &UpdateModelSettingsRequest,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<ModelSettingsResponse, update::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/modelSettings", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(update::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PATCH);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(update::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(update::Error::SerializeError)?;
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(update::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(update::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ModelSettingsResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| update::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(update::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod update {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod time_series_instances {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        x_ms_continuation: Option<&str>,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<GetInstancesPage, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/instances", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GetInstancesPage =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_batch(
+        operation_config: &crate::OperationConfig,
+        parameters: &InstancesBatchRequest,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<InstancesBatchResponse, execute_batch::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/instances/$batch", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(execute_batch::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_batch::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(execute_batch::Error::SerializeError)?;
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute_batch::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_batch::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: InstancesBatchResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute_batch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute_batch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_batch::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_batch {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn suggest(
+        operation_config: &crate::OperationConfig,
+        parameters: &InstancesSuggestRequest,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<InstancesSuggestResponse, suggest::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/instances/suggest", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(suggest::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(suggest::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(suggest::Error::SerializeError)?;
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(suggest::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(suggest::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: InstancesSuggestResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| suggest::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| suggest::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(suggest::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod suggest {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn search(
+        operation_config: &crate::OperationConfig,
+        x_ms_continuation: Option<&str>,
+        parameters: &SearchInstancesRequest,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<SearchInstancesResponsePage, search::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/instances/search", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(search::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(search::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        let req_body = azure_core::to_json(parameters).map_err(search::Error::SerializeError)?;
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(search::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(search::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: SearchInstancesResponsePage =
+                    serde_json::from_slice(rsp_body).map_err(|source| search::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| search::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(search::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod search {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod time_series_types {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        x_ms_continuation: Option<&str>,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<GetTypesPage, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/types", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GetTypesPage =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_batch(
+        operation_config: &crate::OperationConfig,
+        parameters: &TypesBatchRequest,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<TypesBatchResponse, execute_batch::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/types/$batch", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(execute_batch::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_batch::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(execute_batch::Error::SerializeError)?;
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute_batch::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_batch::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: TypesBatchResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute_batch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute_batch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_batch::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_batch {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod time_series_hierarchies {
+    use crate::models::*;
+    pub async fn list(
+        operation_config: &crate::OperationConfig,
+        x_ms_continuation: Option<&str>,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<GetHierarchiesPage, list::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/hierarchies", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(list::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::GET);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(list::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(x_ms_continuation) = x_ms_continuation {
+            req_builder = req_builder.header("x-ms-continuation", x_ms_continuation);
+        }
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(list::Error::BuildRequestError)?;
+        let rsp = http_client.execute_request(req).await.map_err(list::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: GetHierarchiesPage =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| list::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(list::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod list {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn execute_batch(
+        operation_config: &crate::OperationConfig,
+        parameters: &HierarchiesBatchRequest,
+        x_ms_client_request_id: Option<&str>,
+        x_ms_client_session_id: Option<&str>,
+    ) -> std::result::Result<HierarchiesBatchResponse, execute_batch::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/timeseries/hierarchies/$batch", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(execute_batch::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(execute_batch::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(parameters).map_err(execute_batch::Error::SerializeError)?;
+        if let Some(x_ms_client_request_id) = x_ms_client_request_id {
+            req_builder = req_builder.header("x-ms-client-request-id", x_ms_client_request_id);
+        }
+        if let Some(x_ms_client_session_id) = x_ms_client_session_id {
+            req_builder = req_builder.header("x-ms-client-session-id", x_ms_client_session_id);
+        }
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(execute_batch::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(execute_batch::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: HierarchiesBatchResponse =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute_batch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: TsiError =
+                    serde_json::from_slice(rsp_body).map_err(|source| execute_batch::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(execute_batch::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod execute_batch {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::TsiError,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/videoanalyzer/Cargo.toml b/services/svc/videoanalyzer/Cargo.toml
new file mode 100644
index 0000000000..599decc715
--- /dev/null
+++ b/services/svc/videoanalyzer/Cargo.toml
@@ -0,0 +1,23 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_videoanalyzer"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-ava-edge-1-0-0-preview"]
+"package-ava-edge-1-0-0-preview" = []
diff --git a/services/svc/videoanalyzer/src/lib.rs b/services/svc/videoanalyzer/src/lib.rs
new file mode 100644
index 0000000000..cda9d242c7
--- /dev/null
+++ b/services/svc/videoanalyzer/src/lib.rs
@@ -0,0 +1,61 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-ava-edge-1-0-0-preview")]
+mod package_ava_edge_1_0_0_preview;
+use azure_core::setters;
+#[cfg(feature = "package-ava-edge-1-0-0-preview")]
+pub use package_ava_edge_1_0_0_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/mod.rs b/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/mod.rs
new file mode 100644
index 0000000000..cb4128dc98
--- /dev/null
+++ b/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "1.0.0";
diff --git a/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/models.rs b/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/models.rs
new file mode 100644
index 0000000000..09b068361e
--- /dev/null
+++ b/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/models.rs
@@ -0,0 +1,760 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipeline {
+    pub name: String,
+    #[serde(rename = "systemData", default, skip_serializing_if = "Option::is_none")]
+    pub system_data: Option<SystemData>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<LivePipelineProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "topologyName", default, skip_serializing_if = "Option::is_none")]
+    pub topology_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<ParameterDefinition>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub state: Option<live_pipeline_properties::State>,
+}
+pub mod live_pipeline_properties {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum State {
+        #[serde(rename = "inactive")]
+        Inactive,
+        #[serde(rename = "activating")]
+        Activating,
+        #[serde(rename = "active")]
+        Active,
+        #[serde(rename = "deactivating")]
+        Deactivating,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterDefinition {
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineCollection {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<LivePipeline>,
+    #[serde(rename = "@continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineTopologyCollection {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub value: Vec<PipelineTopology>,
+    #[serde(rename = "@continuationToken", default, skip_serializing_if = "Option::is_none")]
+    pub continuation_token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineTopology {
+    pub name: String,
+    #[serde(rename = "systemData", default, skip_serializing_if = "Option::is_none")]
+    pub system_data: Option<SystemData>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub properties: Option<PipelineTopologyProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineTopologyProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub parameters: Vec<ParameterDeclaration>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sources: Vec<SourceNodeBase>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub processors: Vec<ProcessorNodeBase>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sinks: Vec<SinkNodeBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SystemData {
+    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
+    pub created_at: Option<String>,
+    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
+    pub last_modified_at: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ParameterDeclaration {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub type_: parameter_declaration::Type,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub default: Option<String>,
+}
+pub mod parameter_declaration {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Type {
+        #[serde(rename = "string")]
+        String,
+        #[serde(rename = "secretString")]
+        SecretString,
+        #[serde(rename = "int")]
+        Int,
+        #[serde(rename = "double")]
+        Double,
+        #[serde(rename = "bool")]
+        Bool,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SourceNodeBase {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    pub name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct RtspSource {
+    #[serde(flatten)]
+    pub source_node_base: SourceNodeBase,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub transport: Option<rtsp_source::Transport>,
+    pub endpoint: EndpointBase,
+}
+pub mod rtsp_source {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Transport {
+        #[serde(rename = "http")]
+        Http,
+        #[serde(rename = "tcp")]
+        Tcp,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IotHubMessageSource {
+    #[serde(flatten)]
+    pub source_node_base: SourceNodeBase,
+    #[serde(rename = "hubInputName", default, skip_serializing_if = "Option::is_none")]
+    pub hub_input_name: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct IotHubMessageSink {
+    #[serde(flatten)]
+    pub sink_node_base: SinkNodeBase,
+    #[serde(rename = "hubOutputName")]
+    pub hub_output_name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct EndpointBase {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub credentials: Option<CredentialsBase>,
+    pub url: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CredentialsBase {
+    #[serde(rename = "@type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UsernamePasswordCredentials {
+    #[serde(flatten)]
+    pub credentials_base: CredentialsBase,
+    pub username: String,
+    pub password: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpHeaderCredentials {
+    #[serde(flatten)]
+    pub credentials_base: CredentialsBase,
+    #[serde(rename = "headerName")]
+    pub header_name: String,
+    #[serde(rename = "headerValue")]
+    pub header_value: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct UnsecuredEndpoint {
+    #[serde(flatten)]
+    pub endpoint_base: EndpointBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TlsEndpoint {
+    #[serde(flatten)]
+    pub endpoint_base: EndpointBase,
+    #[serde(rename = "trustedCertificates", default, skip_serializing_if = "Option::is_none")]
+    pub trusted_certificates: Option<CertificateSource>,
+    #[serde(rename = "validationOptions", default, skip_serializing_if = "Option::is_none")]
+    pub validation_options: Option<TlsValidationOptions>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CertificateSource {
+    #[serde(rename = "@type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct TlsValidationOptions {
+    #[serde(rename = "ignoreHostname", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_hostname: Option<String>,
+    #[serde(rename = "ignoreSignature", default, skip_serializing_if = "Option::is_none")]
+    pub ignore_signature: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PemCertificateList {
+    #[serde(flatten)]
+    pub certificate_source: CertificateSource,
+    pub certificates: Vec<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SinkNodeBase {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    pub name: String,
+    pub inputs: Vec<NodeInput>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NodeInput {
+    #[serde(rename = "nodeName")]
+    pub node_name: String,
+    #[serde(rename = "outputSelectors", default, skip_serializing_if = "Vec::is_empty")]
+    pub output_selectors: Vec<OutputSelector>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct OutputSelector {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub property: Option<output_selector::Property>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub operator: Option<output_selector::Operator>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub value: Option<String>,
+}
+pub mod output_selector {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Property {
+        #[serde(rename = "mediaType")]
+        MediaType,
+    }
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Operator {
+        #[serde(rename = "is")]
+        Is,
+        #[serde(rename = "isNot")]
+        IsNot,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct FileSink {
+    #[serde(flatten)]
+    pub sink_node_base: SinkNodeBase,
+    #[serde(rename = "baseDirectoryPath")]
+    pub base_directory_path: String,
+    #[serde(rename = "fileNamePattern")]
+    pub file_name_pattern: String,
+    #[serde(rename = "maximumSizeMiB")]
+    pub maximum_size_mi_b: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VideoCreationProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(rename = "segmentLength", default, skip_serializing_if = "Option::is_none")]
+    pub segment_length: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct VideoSink {
+    #[serde(flatten)]
+    pub sink_node_base: SinkNodeBase,
+    #[serde(rename = "videoName")]
+    pub video_name: String,
+    #[serde(rename = "videoCreationProperties", default, skip_serializing_if = "Option::is_none")]
+    pub video_creation_properties: Option<VideoCreationProperties>,
+    #[serde(rename = "localMediaCachePath")]
+    pub local_media_cache_path: String,
+    #[serde(rename = "localMediaCacheMaximumSizeMiB")]
+    pub local_media_cache_maximum_size_mi_b: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProcessorNodeBase {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    pub name: String,
+    pub inputs: Vec<NodeInput>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MotionDetectionProcessor {
+    #[serde(flatten)]
+    pub processor_node_base: ProcessorNodeBase,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sensitivity: Option<motion_detection_processor::Sensitivity>,
+    #[serde(rename = "outputMotionRegion", default, skip_serializing_if = "Option::is_none")]
+    pub output_motion_region: Option<bool>,
+    #[serde(rename = "eventAggregationWindow", default, skip_serializing_if = "Option::is_none")]
+    pub event_aggregation_window: Option<String>,
+}
+pub mod motion_detection_processor {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Sensitivity {
+        #[serde(rename = "low")]
+        Low,
+        #[serde(rename = "medium")]
+        Medium,
+        #[serde(rename = "high")]
+        High,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ObjectTrackingProcessor {
+    #[serde(flatten)]
+    pub processor_node_base: ProcessorNodeBase,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub accuracy: Option<object_tracking_processor::Accuracy>,
+}
+pub mod object_tracking_processor {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Accuracy {
+        #[serde(rename = "low")]
+        Low,
+        #[serde(rename = "medium")]
+        Medium,
+        #[serde(rename = "high")]
+        High,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LineCrossingProcessor {
+    #[serde(flatten)]
+    pub processor_node_base: ProcessorNodeBase,
+    pub lines: Vec<NamedLineBase>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExtensionProcessorBase {
+    #[serde(flatten)]
+    pub processor_node_base: ProcessorNodeBase,
+    pub endpoint: EndpointBase,
+    pub image: ImageProperties,
+    #[serde(rename = "samplingOptions", default, skip_serializing_if = "Option::is_none")]
+    pub sampling_options: Option<SamplingOptions>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GrpcExtension {
+    #[serde(flatten)]
+    pub extension_processor_base: ExtensionProcessorBase,
+    #[serde(rename = "dataTransfer")]
+    pub data_transfer: GrpcExtensionDataTransfer,
+    #[serde(rename = "extensionConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub extension_configuration: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GrpcExtensionDataTransfer {
+    #[serde(rename = "sharedMemorySizeMiB", default, skip_serializing_if = "Option::is_none")]
+    pub shared_memory_size_mi_b: Option<String>,
+    pub mode: grpc_extension_data_transfer::Mode,
+}
+pub mod grpc_extension_data_transfer {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Mode {
+        #[serde(rename = "embedded")]
+        Embedded,
+        #[serde(rename = "sharedMemory")]
+        SharedMemory,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct HttpExtension {
+    #[serde(flatten)]
+    pub extension_processor_base: ExtensionProcessorBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageProperties {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scale: Option<ImageScale>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<ImageFormatProperties>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SamplingOptions {
+    #[serde(rename = "skipSamplesWithoutAnnotation", default, skip_serializing_if = "Option::is_none")]
+    pub skip_samples_without_annotation: Option<String>,
+    #[serde(rename = "maximumSamplesPerSecond", default, skip_serializing_if = "Option::is_none")]
+    pub maximum_samples_per_second: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageScale {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mode: Option<image_scale::Mode>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub width: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub height: Option<String>,
+}
+pub mod image_scale {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Mode {
+        #[serde(rename = "preserveAspectRatio")]
+        PreserveAspectRatio,
+        #[serde(rename = "pad")]
+        Pad,
+        #[serde(rename = "stretch")]
+        Stretch,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageFormatProperties {
+    #[serde(rename = "@type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageFormatRaw {
+    #[serde(flatten)]
+    pub image_format_properties: ImageFormatProperties,
+    #[serde(rename = "pixelFormat")]
+    pub pixel_format: image_format_raw::PixelFormat,
+}
+pub mod image_format_raw {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum PixelFormat {
+        #[serde(rename = "yuv420p")]
+        Yuv420p,
+        #[serde(rename = "rgb565be")]
+        Rgb565be,
+        #[serde(rename = "rgb565le")]
+        Rgb565le,
+        #[serde(rename = "rgb555be")]
+        Rgb555be,
+        #[serde(rename = "rgb555le")]
+        Rgb555le,
+        #[serde(rename = "rgb24")]
+        Rgb24,
+        #[serde(rename = "bgr24")]
+        Bgr24,
+        #[serde(rename = "argb")]
+        Argb,
+        #[serde(rename = "rgba")]
+        Rgba,
+        #[serde(rename = "abgr")]
+        Abgr,
+        #[serde(rename = "bgra")]
+        Bgra,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageFormatJpeg {
+    #[serde(flatten)]
+    pub image_format_properties: ImageFormatProperties,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub quality: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageFormatBmp {
+    #[serde(flatten)]
+    pub image_format_properties: ImageFormatProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ImageFormatPng {
+    #[serde(flatten)]
+    pub image_format_properties: ImageFormatProperties,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NamedLineBase {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    pub name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NamedLineString {
+    #[serde(flatten)]
+    pub named_line_base: NamedLineBase,
+    pub line: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NamedPolygonBase {
+    #[serde(rename = "@type")]
+    pub type_: String,
+    pub name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NamedPolygonString {
+    #[serde(flatten)]
+    pub named_polygon_base: NamedPolygonBase,
+    pub polygon: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SignalGateProcessor {
+    #[serde(flatten)]
+    pub processor_node_base: ProcessorNodeBase,
+    #[serde(rename = "activationEvaluationWindow", default, skip_serializing_if = "Option::is_none")]
+    pub activation_evaluation_window: Option<String>,
+    #[serde(rename = "activationSignalOffset", default, skip_serializing_if = "Option::is_none")]
+    pub activation_signal_offset: Option<String>,
+    #[serde(rename = "minimumActivationTime", default, skip_serializing_if = "Option::is_none")]
+    pub minimum_activation_time: Option<String>,
+    #[serde(rename = "maximumActivationTime", default, skip_serializing_if = "Option::is_none")]
+    pub maximum_activation_time: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisOperationBase {
+    #[serde(rename = "@type")]
+    pub type_: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisCustomOperation {
+    #[serde(flatten)]
+    pub spatial_analysis_operation_base: SpatialAnalysisOperationBase,
+    #[serde(rename = "extensionConfiguration")]
+    pub extension_configuration: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisTypedOperationBase {
+    #[serde(flatten)]
+    pub spatial_analysis_operation_base: SpatialAnalysisOperationBase,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub debug: Option<String>,
+    #[serde(rename = "cameraConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub camera_configuration: Option<String>,
+    #[serde(rename = "detectorNodeConfiguration", default, skip_serializing_if = "Option::is_none")]
+    pub detector_node_configuration: Option<String>,
+    #[serde(rename = "enableFaceMaskClassifier", default, skip_serializing_if = "Option::is_none")]
+    pub enable_face_mask_classifier: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisOperationEventBase {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub threshold: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub focus: Option<spatial_analysis_operation_event_base::Focus>,
+}
+pub mod spatial_analysis_operation_event_base {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Focus {
+        #[serde(rename = "center")]
+        Center,
+        #[serde(rename = "bottomCenter")]
+        BottomCenter,
+        #[serde(rename = "footprint")]
+        Footprint,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonCountEvent {
+    #[serde(flatten)]
+    pub spatial_analysis_operation_event_base: SpatialAnalysisOperationEventBase,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub trigger: Option<spatial_analysis_person_count_event::Trigger>,
+    #[serde(rename = "outputFrequency", default, skip_serializing_if = "Option::is_none")]
+    pub output_frequency: Option<String>,
+}
+pub mod spatial_analysis_person_count_event {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Trigger {
+        #[serde(rename = "event")]
+        Event,
+        #[serde(rename = "interval")]
+        Interval,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonCountZoneEvents {
+    pub zone: NamedPolygonBase,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub events: Vec<SpatialAnalysisPersonCountEvent>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonCountOperation {
+    #[serde(flatten)]
+    pub spatial_analysis_typed_operation_base: SpatialAnalysisTypedOperationBase,
+    pub zones: Vec<SpatialAnalysisPersonCountZoneEvents>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonZoneCrossingEvent {
+    #[serde(flatten)]
+    pub spatial_analysis_operation_event_base: SpatialAnalysisOperationEventBase,
+    #[serde(rename = "eventType", default, skip_serializing_if = "Option::is_none")]
+    pub event_type: Option<spatial_analysis_person_zone_crossing_event::EventType>,
+}
+pub mod spatial_analysis_person_zone_crossing_event {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum EventType {
+        #[serde(rename = "zoneCrossing")]
+        ZoneCrossing,
+        #[serde(rename = "zoneDwellTime")]
+        ZoneDwellTime,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonZoneCrossingZoneEvents {
+    pub zone: NamedPolygonBase,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub events: Vec<SpatialAnalysisPersonZoneCrossingEvent>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonZoneCrossingOperation {
+    #[serde(flatten)]
+    pub spatial_analysis_typed_operation_base: SpatialAnalysisTypedOperationBase,
+    pub zones: Vec<SpatialAnalysisPersonZoneCrossingZoneEvents>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonDistanceEvent {
+    #[serde(flatten)]
+    pub spatial_analysis_operation_event_base: SpatialAnalysisOperationEventBase,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub trigger: Option<spatial_analysis_person_distance_event::Trigger>,
+    #[serde(rename = "outputFrequency", default, skip_serializing_if = "Option::is_none")]
+    pub output_frequency: Option<String>,
+    #[serde(rename = "minimumDistanceThreshold", default, skip_serializing_if = "Option::is_none")]
+    pub minimum_distance_threshold: Option<String>,
+    #[serde(rename = "maximumDistanceThreshold", default, skip_serializing_if = "Option::is_none")]
+    pub maximum_distance_threshold: Option<String>,
+}
+pub mod spatial_analysis_person_distance_event {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum Trigger {
+        #[serde(rename = "event")]
+        Event,
+        #[serde(rename = "interval")]
+        Interval,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonDistanceZoneEvents {
+    pub zone: NamedPolygonBase,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub events: Vec<SpatialAnalysisPersonDistanceEvent>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonDistanceOperation {
+    #[serde(flatten)]
+    pub spatial_analysis_typed_operation_base: SpatialAnalysisTypedOperationBase,
+    pub zones: Vec<SpatialAnalysisPersonDistanceZoneEvents>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonLineCrossingEvent {
+    #[serde(flatten)]
+    pub spatial_analysis_operation_event_base: SpatialAnalysisOperationEventBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonLineCrossingLineEvents {
+    pub line: NamedLineBase,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub events: Vec<SpatialAnalysisPersonLineCrossingEvent>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct SpatialAnalysisPersonLineCrossingOperation {
+    #[serde(flatten)]
+    pub spatial_analysis_typed_operation_base: SpatialAnalysisTypedOperationBase,
+    pub lines: Vec<SpatialAnalysisPersonLineCrossingLineEvents>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct CognitiveServicesVisionProcessor {
+    #[serde(flatten)]
+    pub processor_node_base: ProcessorNodeBase,
+    pub endpoint: EndpointBase,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image: Option<ImageProperties>,
+    #[serde(rename = "samplingOptions", default, skip_serializing_if = "Option::is_none")]
+    pub sampling_options: Option<SamplingOptions>,
+    pub operation: SpatialAnalysisOperationBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MethodRequest {
+    #[serde(rename = "methodName")]
+    pub method_name: String,
+    #[serde(rename = "@apiVersion", default, skip_serializing_if = "Option::is_none")]
+    pub api_version: Option<method_request::ApiVersion>,
+}
+pub mod method_request {
+    use super::*;
+    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+    pub enum ApiVersion {
+        #[serde(rename = "1.0")]
+        _1_0,
+    }
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineTopologySetRequest {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    #[serde(rename = "pipelineTopology")]
+    pub pipeline_topology: PipelineTopology,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineTopologySetRequestBody {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    #[serde(flatten)]
+    pub pipeline_topology: PipelineTopology,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineSetRequest {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    #[serde(rename = "livePipeline")]
+    pub live_pipeline: LivePipeline,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineSetRequestBody {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    #[serde(flatten)]
+    pub live_pipeline: LivePipeline,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct MethodRequestEmptyBodyBase {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+    pub name: String,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineTopologyListRequest {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineTopologyGetRequest {
+    #[serde(flatten)]
+    pub method_request_empty_body_base: MethodRequestEmptyBodyBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct PipelineTopologyDeleteRequest {
+    #[serde(flatten)]
+    pub method_request_empty_body_base: MethodRequestEmptyBodyBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineListRequest {
+    #[serde(flatten)]
+    pub method_request: MethodRequest,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineGetRequest {
+    #[serde(flatten)]
+    pub method_request_empty_body_base: MethodRequestEmptyBodyBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineActivateRequest {
+    #[serde(flatten)]
+    pub method_request_empty_body_base: MethodRequestEmptyBodyBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineDeactivateRequest {
+    #[serde(flatten)]
+    pub method_request_empty_body_base: MethodRequestEmptyBodyBase,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LivePipelineDeleteRequest {
+    #[serde(flatten)]
+    pub method_request_empty_body_base: MethodRequestEmptyBodyBase,
+}
diff --git a/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/operations.rs b/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/operations.rs
new file mode 100644
index 0000000000..82a7a1cf58
--- /dev/null
+++ b/services/svc/videoanalyzer/src/package_ava_edge_1_0_0_preview/operations.rs
@@ -0,0 +1,5 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
diff --git a/services/svc/webpubsub/Cargo.toml b/services/svc/webpubsub/Cargo.toml
new file mode 100644
index 0000000000..011de767db
--- /dev/null
+++ b/services/svc/webpubsub/Cargo.toml
@@ -0,0 +1,25 @@
+# generated by AutoRust 0.1.0
+[package]
+name = "azure_svc_webpubsub"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+azure_core = { path = "../../../sdk/core", version = "0.1.0" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+bytes = "1.0"
+thiserror = "1.0"
+http = "0.2"
+url = "2.2"
+
+[dev-dependencies]
+azure_identity = { path = "../../../sdk/identity", version = "0.1.0" }
+tokio = { version = "1.0", features = ["macros"] }
+
+[features]
+default = ["package-2021-10-01"]
+"package-2021-10-01" = []
+"package-2021-08-01-preview" = []
+"package-2021-05-01-preview" = []
diff --git a/services/svc/webpubsub/src/lib.rs b/services/svc/webpubsub/src/lib.rs
new file mode 100644
index 0000000000..bd5dbefcaa
--- /dev/null
+++ b/services/svc/webpubsub/src/lib.rs
@@ -0,0 +1,69 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#[cfg(feature = "package-2021-10-01")]
+mod package_2021_10_01;
+#[cfg(feature = "package-2021-10-01")]
+pub use package_2021_10_01::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-08-01-preview")]
+mod package_2021_08_01_preview;
+#[cfg(feature = "package-2021-08-01-preview")]
+pub use package_2021_08_01_preview::{models, operations, API_VERSION};
+#[cfg(feature = "package-2021-05-01-preview")]
+mod package_2021_05_01_preview;
+use azure_core::setters;
+#[cfg(feature = "package-2021-05-01-preview")]
+pub use package_2021_05_01_preview::{models, operations, API_VERSION};
+pub fn config(
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+) -> OperationConfigBuilder {
+    OperationConfigBuilder {
+        api_version: None,
+        http_client,
+        base_path: None,
+        token_credential,
+        token_credential_resource: None,
+    }
+}
+pub struct OperationConfigBuilder {
+    api_version: Option<String>,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: Option<String>,
+    token_credential: Box<dyn azure_core::TokenCredential>,
+    token_credential_resource: Option<String>,
+}
+impl OperationConfigBuilder {
+    setters! { api_version : String => Some (api_version) , base_path : String => Some (base_path) , token_credential_resource : String => Some (token_credential_resource) , }
+    pub fn build(self) -> OperationConfig {
+        OperationConfig {
+            api_version: self.api_version.unwrap_or(API_VERSION.to_owned()),
+            http_client: self.http_client,
+            base_path: self.base_path.unwrap_or("https://management.azure.com".to_owned()),
+            token_credential: Some(self.token_credential),
+            token_credential_resource: self.token_credential_resource.unwrap_or("https://management.azure.com/".to_owned()),
+        }
+    }
+}
+pub struct OperationConfig {
+    api_version: String,
+    http_client: std::sync::Arc<dyn azure_core::HttpClient>,
+    base_path: String,
+    token_credential: Option<Box<dyn azure_core::TokenCredential>>,
+    token_credential_resource: String,
+}
+impl OperationConfig {
+    pub fn api_version(&self) -> &str {
+        self.api_version.as_str()
+    }
+    pub fn http_client(&self) -> &dyn azure_core::HttpClient {
+        self.http_client.as_ref()
+    }
+    pub fn base_path(&self) -> &str {
+        self.base_path.as_str()
+    }
+    pub fn token_credential(&self) -> Option<&dyn azure_core::TokenCredential> {
+        self.token_credential.as_deref()
+    }
+    pub fn token_credential_resource(&self) -> &str {
+        self.token_credential_resource.as_str()
+    }
+}
diff --git a/services/svc/webpubsub/src/package_2021_05_01_preview/mod.rs b/services/svc/webpubsub/src/package_2021_05_01_preview/mod.rs
new file mode 100644
index 0000000000..465cf54437
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_05_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-05-01-preview";
diff --git a/services/svc/webpubsub/src/package_2021_05_01_preview/models.rs b/services/svc/webpubsub/src/package_2021_05_01_preview/models.rs
new file mode 100644
index 0000000000..6591fd6b01
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_05_01_preview/models.rs
@@ -0,0 +1,4 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
diff --git a/services/svc/webpubsub/src/package_2021_05_01_preview/operations.rs b/services/svc/webpubsub/src/package_2021_05_01_preview/operations.rs
new file mode 100644
index 0000000000..04f1345e3d
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_05_01_preview/operations.rs
@@ -0,0 +1,964 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod health_api {
+    use crate::models::*;
+    pub async fn get_service_status(operation_config: &crate::OperationConfig) -> std::result::Result<(), get_service_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/health", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_service_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_service_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_service_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_service_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(get_service_status::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod get_service_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod web_pub_sub {
+    use crate::models::*;
+    pub async fn send_to_all(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        excluded: &Vec<&str>,
+        message: &str,
+    ) -> std::result::Result<(), send_to_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/:send", operation_config.base_path(), hub);
+        let mut url = url::Url::parse(url_str).map_err(send_to_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(message).map_err(send_to_all::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => Err(send_to_all::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod send_to_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn close_connection(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+        reason: Option<&str>,
+    ) -> std::result::Result<(), close_connection::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/connections/{}", operation_config.base_path(), hub, connection_id);
+        let mut url = url::Url::parse(url_str).map_err(close_connection::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(close_connection::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(reason) = reason {
+            url.query_pairs_mut().append_pair("reason", reason);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(close_connection::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(close_connection::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(close_connection::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod close_connection {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn connection_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), connection_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/connections/{}", operation_config.base_path(), hub, connection_id);
+        let mut url = url::Url::parse(url_str).map_err(connection_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(connection_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(connection_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(connection_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(connection_exists::Error::NotFound404 {}),
+            status_code => Err(connection_exists::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod connection_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_connection(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+        message: &str,
+    ) -> std::result::Result<(), send_to_connection::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/connections/{}/:send",
+            operation_config.base_path(),
+            hub,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(send_to_connection::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_connection::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(message).map_err(send_to_connection::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_connection::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_connection::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => Err(send_to_connection::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod send_to_connection {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn group_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+    ) -> std::result::Result<(), group_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/groups/{}", operation_config.base_path(), hub, group);
+        let mut url = url::Url::parse(url_str).map_err(group_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(group_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(group_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(group_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(group_exists::Error::NotFound404 {}),
+            status_code => Err(group_exists::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod group_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        excluded: &Vec<&str>,
+        message: &str,
+    ) -> std::result::Result<(), send_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/groups/{}/:send", operation_config.base_path(), hub, group);
+        let mut url = url::Url::parse(url_str).map_err(send_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(message).map_err(send_to_group::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => Err(send_to_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod send_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_connection_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), add_connection_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/groups/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            group,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_connection_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_connection_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(add_connection_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_connection_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(add_connection_to_group::Error::NotFound404 {}),
+            status_code => Err(add_connection_to_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod add_connection_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_connection_from_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), remove_connection_from_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/groups/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            group,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_connection_from_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_connection_from_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_connection_from_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_connection_from_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(remove_connection_from_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod remove_connection_from_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn user_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), user_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(user_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(user_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(user_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(user_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(user_exists::Error::NotFound404 {}),
+            status_code => Err(user_exists::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod user_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_user(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+        message: &str,
+    ) -> std::result::Result<(), send_to_user::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}/:send", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(send_to_user::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_user::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(message).map_err(send_to_user::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_user::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_user::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => Err(send_to_user::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod send_to_user {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_user_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), add_user_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/users/{}/groups/{}",
+            operation_config.base_path(),
+            hub,
+            user_id,
+            group
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_user_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_user_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_user_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_user_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(add_user_to_group::Error::NotFound404 {}),
+            status_code => Err(add_user_to_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod add_user_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_user_from_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), remove_user_from_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/users/{}/groups/{}",
+            operation_config.base_path(),
+            hub,
+            user_id,
+            group
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_user_from_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_user_from_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_user_from_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_user_from_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(remove_user_from_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod remove_user_from_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_user_from_all_groups(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), remove_user_from_all_groups::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}/groups", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(remove_user_from_all_groups::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_user_from_all_groups::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_user_from_all_groups::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_user_from_all_groups::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(remove_user_from_all_groups::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod remove_user_from_all_groups {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn grant_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), grant_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(grant_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(grant_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(grant_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(grant_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(grant_permission::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod grant_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn revoke_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), revoke_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(revoke_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(revoke_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(revoke_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(revoke_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(revoke_permission::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod revoke_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn check_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), check_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(check_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(check_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(check_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(check_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(check_permission::Error::NotFound404 {}),
+            status_code => Err(check_permission::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod check_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/webpubsub/src/package_2021_08_01_preview/mod.rs b/services/svc/webpubsub/src/package_2021_08_01_preview/mod.rs
new file mode 100644
index 0000000000..e9fe758360
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_08_01_preview/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-08-01-preview";
diff --git a/services/svc/webpubsub/src/package_2021_08_01_preview/models.rs b/services/svc/webpubsub/src/package_2021_08_01_preview/models.rs
new file mode 100644
index 0000000000..66dbca4378
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_08_01_preview/models.rs
@@ -0,0 +1,9 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ClientTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<String>,
+}
diff --git a/services/svc/webpubsub/src/package_2021_08_01_preview/operations.rs b/services/svc/webpubsub/src/package_2021_08_01_preview/operations.rs
new file mode 100644
index 0000000000..e42c769164
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_08_01_preview/operations.rs
@@ -0,0 +1,1034 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod health_api {
+    use crate::models::*;
+    pub async fn get_service_status(operation_config: &crate::OperationConfig) -> std::result::Result<(), get_service_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/health", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_service_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_service_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_service_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_service_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(get_service_status::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod get_service_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod web_pub_sub {
+    use crate::models::*;
+    pub async fn generate_client_token(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: Option<&str>,
+        role: &Vec<&str>,
+        minutes_to_expire: Option<i32>,
+    ) -> std::result::Result<ClientTokenResponse, generate_client_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/:generateToken", operation_config.base_path(), hub);
+        let mut url = url::Url::parse(url_str).map_err(generate_client_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(generate_client_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(user_id) = user_id {
+            url.query_pairs_mut().append_pair("userId", user_id);
+        }
+        for value in role {
+            url.query_pairs_mut().append_pair("role", value.to_string().as_str());
+        }
+        if let Some(minutes_to_expire) = minutes_to_expire {
+            url.query_pairs_mut()
+                .append_pair("minutesToExpire", minutes_to_expire.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(generate_client_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(generate_client_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ClientTokenResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| generate_client_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => Err(generate_client_token::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod generate_client_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_all(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        excluded: &Vec<&str>,
+        message: &str,
+    ) -> std::result::Result<(), send_to_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/:send", operation_config.base_path(), hub);
+        let mut url = url::Url::parse(url_str).map_err(send_to_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(message).map_err(send_to_all::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => Err(send_to_all::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod send_to_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn close_connection(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+        reason: Option<&str>,
+    ) -> std::result::Result<(), close_connection::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/connections/{}", operation_config.base_path(), hub, connection_id);
+        let mut url = url::Url::parse(url_str).map_err(close_connection::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(close_connection::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(reason) = reason {
+            url.query_pairs_mut().append_pair("reason", reason);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(close_connection::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(close_connection::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(close_connection::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod close_connection {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn connection_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), connection_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/connections/{}", operation_config.base_path(), hub, connection_id);
+        let mut url = url::Url::parse(url_str).map_err(connection_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(connection_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(connection_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(connection_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(connection_exists::Error::NotFound404 {}),
+            status_code => Err(connection_exists::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod connection_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_connection(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+        message: &str,
+    ) -> std::result::Result<(), send_to_connection::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/connections/{}/:send",
+            operation_config.base_path(),
+            hub,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(send_to_connection::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_connection::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(message).map_err(send_to_connection::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_connection::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_connection::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => Err(send_to_connection::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod send_to_connection {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn group_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+    ) -> std::result::Result<(), group_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/groups/{}", operation_config.base_path(), hub, group);
+        let mut url = url::Url::parse(url_str).map_err(group_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(group_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(group_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(group_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(group_exists::Error::NotFound404 {}),
+            status_code => Err(group_exists::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod group_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        excluded: &Vec<&str>,
+        message: &str,
+    ) -> std::result::Result<(), send_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/groups/{}/:send", operation_config.base_path(), hub, group);
+        let mut url = url::Url::parse(url_str).map_err(send_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(message).map_err(send_to_group::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => Err(send_to_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod send_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_connection_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), add_connection_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/groups/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            group,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_connection_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_connection_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(add_connection_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_connection_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(add_connection_to_group::Error::NotFound404 {}),
+            status_code => Err(add_connection_to_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod add_connection_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_connection_from_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), remove_connection_from_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/groups/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            group,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_connection_from_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_connection_from_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_connection_from_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_connection_from_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(remove_connection_from_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod remove_connection_from_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn user_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), user_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(user_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(user_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(user_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(user_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(user_exists::Error::NotFound404 {}),
+            status_code => Err(user_exists::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod user_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_user(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+        message: &str,
+    ) -> std::result::Result<(), send_to_user::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}/:send", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(send_to_user::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_user::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(message).map_err(send_to_user::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_user::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_user::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => Err(send_to_user::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod send_to_user {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_user_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), add_user_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/users/{}/groups/{}",
+            operation_config.base_path(),
+            hub,
+            user_id,
+            group
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_user_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_user_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_user_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_user_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(add_user_to_group::Error::NotFound404 {}),
+            status_code => Err(add_user_to_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod add_user_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_user_from_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), remove_user_from_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/users/{}/groups/{}",
+            operation_config.base_path(),
+            hub,
+            user_id,
+            group
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_user_from_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_user_from_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_user_from_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_user_from_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(remove_user_from_group::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod remove_user_from_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_user_from_all_groups(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), remove_user_from_all_groups::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}/groups", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(remove_user_from_all_groups::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_user_from_all_groups::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_user_from_all_groups::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_user_from_all_groups::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(remove_user_from_all_groups::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod remove_user_from_all_groups {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn grant_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), grant_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(grant_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(grant_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(grant_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(grant_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(grant_permission::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod grant_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn revoke_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), revoke_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(revoke_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(revoke_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(revoke_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(revoke_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(revoke_permission::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod revoke_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn check_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), check_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(check_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(check_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(check_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(check_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(check_permission::Error::NotFound404 {}),
+            status_code => Err(check_permission::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod check_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
diff --git a/services/svc/webpubsub/src/package_2021_10_01/mod.rs b/services/svc/webpubsub/src/package_2021_10_01/mod.rs
new file mode 100644
index 0000000000..5b44179ff5
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_10_01/mod.rs
@@ -0,0 +1,3 @@
+pub mod models;
+pub mod operations;
+pub const API_VERSION: &str = "2021-10-01";
diff --git a/services/svc/webpubsub/src/package_2021_10_01/models.rs b/services/svc/webpubsub/src/package_2021_10_01/models.rs
new file mode 100644
index 0000000000..b34f36385b
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_10_01/models.rs
@@ -0,0 +1,29 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(non_camel_case_types)]
+#![allow(unused_imports)]
+use serde::{Deserialize, Serialize};
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ClientTokenResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token: Option<String>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ErrorDetail {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub details: Vec<ErrorDetail>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub inner: Option<InnerError>,
+}
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct InnerError {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub code: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub inner: Box<Option<InnerError>>,
+}
diff --git a/services/svc/webpubsub/src/package_2021_10_01/operations.rs b/services/svc/webpubsub/src/package_2021_10_01/operations.rs
new file mode 100644
index 0000000000..fdaa0bea28
--- /dev/null
+++ b/services/svc/webpubsub/src/package_2021_10_01/operations.rs
@@ -0,0 +1,1446 @@
+#![doc = "generated by AutoRust 0.1.0"]
+#![allow(unused_mut)]
+#![allow(unused_variables)]
+#![allow(unused_imports)]
+use crate::models::*;
+pub mod health_api {
+    use crate::models::*;
+    pub async fn get_service_status(operation_config: &crate::OperationConfig) -> std::result::Result<(), get_service_status::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/health", operation_config.base_path(),);
+        let mut url = url::Url::parse(url_str).map_err(get_service_status::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(get_service_status::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(get_service_status::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(get_service_status::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => Err(get_service_status::Error::DefaultResponse { status_code }),
+        }
+    }
+    pub mod get_service_status {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse { status_code: http::StatusCode },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}
+pub mod web_pub_sub {
+    use crate::models::*;
+    pub async fn generate_client_token(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: Option<&str>,
+        role: &Vec<&str>,
+        minutes_to_expire: Option<i32>,
+    ) -> std::result::Result<ClientTokenResponse, generate_client_token::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/:generateToken", operation_config.base_path(), hub);
+        let mut url = url::Url::parse(url_str).map_err(generate_client_token::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(generate_client_token::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(user_id) = user_id {
+            url.query_pairs_mut().append_pair("userId", user_id);
+        }
+        for value in role {
+            url.query_pairs_mut().append_pair("role", value.to_string().as_str());
+        }
+        if let Some(minutes_to_expire) = minutes_to_expire {
+            url.query_pairs_mut()
+                .append_pair("minutesToExpire", minutes_to_expire.to_string().as_str());
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(generate_client_token::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(generate_client_token::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => {
+                let rsp_body = rsp.body();
+                let rsp_value: ClientTokenResponse = serde_json::from_slice(rsp_body)
+                    .map_err(|source| generate_client_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Ok(rsp_value)
+            }
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| generate_client_token::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(generate_client_token::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod generate_client_token {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn close_all_connections(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        excluded: &Vec<&str>,
+        reason: Option<&str>,
+    ) -> std::result::Result<(), close_all_connections::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/:closeConnections", operation_config.base_path(), hub);
+        let mut url = url::Url::parse(url_str).map_err(close_all_connections::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(close_all_connections::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        if let Some(reason) = reason {
+            url.query_pairs_mut().append_pair("reason", reason);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(close_all_connections::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(close_all_connections::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| close_all_connections::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(close_all_connections::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod close_all_connections {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_all(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        excluded: &Vec<&str>,
+        message: &str,
+    ) -> std::result::Result<(), send_to_all::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/:send", operation_config.base_path(), hub);
+        let mut url = url::Url::parse(url_str).map_err(send_to_all::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_all::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(message).map_err(send_to_all::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_all::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_all::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail =
+                    serde_json::from_slice(rsp_body).map_err(|source| send_to_all::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(send_to_all::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod send_to_all {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn close_connection(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+        reason: Option<&str>,
+    ) -> std::result::Result<(), close_connection::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/connections/{}", operation_config.base_path(), hub, connection_id);
+        let mut url = url::Url::parse(url_str).map_err(close_connection::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(close_connection::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(reason) = reason {
+            url.query_pairs_mut().append_pair("reason", reason);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(close_connection::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(close_connection::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| close_connection::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(close_connection::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod close_connection {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn connection_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), connection_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/connections/{}", operation_config.base_path(), hub, connection_id);
+        let mut url = url::Url::parse(url_str).map_err(connection_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(connection_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(connection_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(connection_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(connection_exists::Error::NotFound404 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| connection_exists::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(connection_exists::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod connection_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_connection(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        connection_id: &str,
+        message: &str,
+    ) -> std::result::Result<(), send_to_connection::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/connections/{}/:send",
+            operation_config.base_path(),
+            hub,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(send_to_connection::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_connection::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(message).map_err(send_to_connection::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_connection::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_connection::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| send_to_connection::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(send_to_connection::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod send_to_connection {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn group_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+    ) -> std::result::Result<(), group_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/groups/{}", operation_config.base_path(), hub, group);
+        let mut url = url::Url::parse(url_str).map_err(group_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(group_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(group_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(group_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(group_exists::Error::NotFound404 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail =
+                    serde_json::from_slice(rsp_body).map_err(|source| group_exists::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(group_exists::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod group_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn close_group_connections(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        excluded: &Vec<&str>,
+        reason: Option<&str>,
+    ) -> std::result::Result<(), close_group_connections::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/groups/{}/:closeConnections",
+            operation_config.base_path(),
+            hub,
+            group
+        );
+        let mut url = url::Url::parse(url_str).map_err(close_group_connections::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(close_group_connections::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        if let Some(reason) = reason {
+            url.query_pairs_mut().append_pair("reason", reason);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(close_group_connections::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(close_group_connections::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| close_group_connections::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(close_group_connections::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod close_group_connections {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        excluded: &Vec<&str>,
+        message: &str,
+    ) -> std::result::Result<(), send_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/groups/{}/:send", operation_config.base_path(), hub, group);
+        let mut url = url::Url::parse(url_str).map_err(send_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        let req_body = azure_core::to_json(message).map_err(send_to_group::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail =
+                    serde_json::from_slice(rsp_body).map_err(|source| send_to_group::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(send_to_group::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod send_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_connection_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), add_connection_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/groups/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            group,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_connection_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_connection_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(add_connection_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_connection_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(add_connection_to_group::Error::NotFound404 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| add_connection_to_group::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_connection_to_group::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_connection_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_connection_from_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        connection_id: &str,
+    ) -> std::result::Result<(), remove_connection_from_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/groups/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            group,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_connection_from_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_connection_from_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_connection_from_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_connection_from_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| remove_connection_from_group::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(remove_connection_from_group::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod remove_connection_from_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn user_exists(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), user_exists::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(user_exists::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(user_exists::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(user_exists::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(user_exists::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(user_exists::Error::NotFound404 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail =
+                    serde_json::from_slice(rsp_body).map_err(|source| user_exists::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(user_exists::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod user_exists {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn close_user_connections(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+        excluded: &Vec<&str>,
+        reason: Option<&str>,
+    ) -> std::result::Result<(), close_user_connections::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/users/{}/:closeConnections",
+            operation_config.base_path(),
+            hub,
+            user_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(close_user_connections::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(close_user_connections::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        for value in excluded {
+            url.query_pairs_mut().append_pair("excluded", value.to_string().as_str());
+        }
+        if let Some(reason) = reason {
+            url.query_pairs_mut().append_pair("reason", reason);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.header(http::header::CONTENT_LENGTH, 0);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(close_user_connections::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(close_user_connections::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| close_user_connections::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(close_user_connections::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod close_user_connections {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn send_to_user(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+        message: &str,
+    ) -> std::result::Result<(), send_to_user::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}/:send", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(send_to_user::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::POST);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(send_to_user::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = azure_core::to_json(message).map_err(send_to_user::Error::SerializeError)?;
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(send_to_user::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(send_to_user::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::ACCEPTED => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail =
+                    serde_json::from_slice(rsp_body).map_err(|source| send_to_user::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(send_to_user::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod send_to_user {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn add_user_to_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), add_user_to_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/users/{}/groups/{}",
+            operation_config.base_path(),
+            hub,
+            user_id,
+            group
+        );
+        let mut url = url::Url::parse(url_str).map_err(add_user_to_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(add_user_to_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(add_user_to_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(add_user_to_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(add_user_to_group::Error::NotFound404 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| add_user_to_group::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(add_user_to_group::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod add_user_to_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_user_from_group(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        group: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), remove_user_from_group::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/users/{}/groups/{}",
+            operation_config.base_path(),
+            hub,
+            user_id,
+            group
+        );
+        let mut url = url::Url::parse(url_str).map_err(remove_user_from_group::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_user_from_group::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_user_from_group::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_user_from_group::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| remove_user_from_group::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(remove_user_from_group::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod remove_user_from_group {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn remove_user_from_all_groups(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        user_id: &str,
+    ) -> std::result::Result<(), remove_user_from_all_groups::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!("{}/api/hubs/{}/users/{}/groups", operation_config.base_path(), hub, user_id);
+        let mut url = url::Url::parse(url_str).map_err(remove_user_from_all_groups::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(remove_user_from_all_groups::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder
+            .body(req_body)
+            .map_err(remove_user_from_all_groups::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(remove_user_from_all_groups::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| remove_user_from_all_groups::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(remove_user_from_all_groups::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod remove_user_from_all_groups {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn grant_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), grant_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(grant_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::PUT);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(grant_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(grant_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(grant_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| grant_permission::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(grant_permission::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod grant_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn revoke_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), revoke_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(revoke_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::DELETE);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(revoke_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(revoke_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(revoke_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::NO_CONTENT => Ok(()),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| revoke_permission::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(revoke_permission::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod revoke_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+    pub async fn check_permission(
+        operation_config: &crate::OperationConfig,
+        hub: &str,
+        permission: &str,
+        connection_id: &str,
+        target_name: Option<&str>,
+    ) -> std::result::Result<(), check_permission::Error> {
+        let http_client = operation_config.http_client();
+        let url_str = &format!(
+            "{}/api/hubs/{}/permissions/{}/connections/{}",
+            operation_config.base_path(),
+            hub,
+            permission,
+            connection_id
+        );
+        let mut url = url::Url::parse(url_str).map_err(check_permission::Error::ParseUrlError)?;
+        let mut req_builder = http::request::Builder::new();
+        req_builder = req_builder.method(http::Method::HEAD);
+        if let Some(token_credential) = operation_config.token_credential() {
+            let token_response = token_credential
+                .get_token(operation_config.token_credential_resource())
+                .await
+                .map_err(check_permission::Error::GetTokenError)?;
+            req_builder = req_builder.header(http::header::AUTHORIZATION, format!("Bearer {}", token_response.token.secret()));
+        }
+        url.query_pairs_mut().append_pair("api-version", operation_config.api_version());
+        if let Some(target_name) = target_name {
+            url.query_pairs_mut().append_pair("targetName", target_name);
+        }
+        let req_body = bytes::Bytes::from_static(azure_core::EMPTY_BODY);
+        req_builder = req_builder.uri(url.as_str());
+        let req = req_builder.body(req_body).map_err(check_permission::Error::BuildRequestError)?;
+        let rsp = http_client
+            .execute_request(req)
+            .await
+            .map_err(check_permission::Error::ExecuteRequestError)?;
+        match rsp.status() {
+            http::StatusCode::OK => Ok(()),
+            http::StatusCode::NOT_FOUND => Err(check_permission::Error::NotFound404 {}),
+            status_code => {
+                let rsp_body = rsp.body();
+                let rsp_value: ErrorDetail = serde_json::from_slice(rsp_body)
+                    .map_err(|source| check_permission::Error::DeserializeError(source, rsp_body.clone()))?;
+                Err(check_permission::Error::DefaultResponse {
+                    status_code,
+                    value: rsp_value,
+                })
+            }
+        }
+    }
+    pub mod check_permission {
+        use crate::{models, models::*};
+        #[derive(Debug, thiserror :: Error)]
+        pub enum Error {
+            #[error("Error response #response_type")]
+            NotFound404 {},
+            #[error("HTTP status code {}", status_code)]
+            DefaultResponse {
+                status_code: http::StatusCode,
+                value: models::ErrorDetail,
+            },
+            #[error("Failed to parse request URL: {0}")]
+            ParseUrlError(url::ParseError),
+            #[error("Failed to build request: {0}")]
+            BuildRequestError(http::Error),
+            #[error("Failed to execute request: {0}")]
+            ExecuteRequestError(azure_core::HttpError),
+            #[error("Failed to serialize request body: {0}")]
+            SerializeError(serde_json::Error),
+            #[error("Failed to deserialize response: {0}, body: {1:?}")]
+            DeserializeError(serde_json::Error, bytes::Bytes),
+            #[error("Failed to get access token: {0}")]
+            GetTokenError(azure_core::Error),
+        }
+    }
+}