#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::de::{value, Deserializer, IntoDeserializer};
use serde::{Deserialize, Serialize, Serializer};
use std::str::FromStr;
#[doc = "Authentication configuration of a cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AuthConfig {
#[serde(rename = "activeDirectoryAuth", default, skip_serializing_if = "Option::is_none")]
pub active_directory_auth: Option<auth_config::ActiveDirectoryAuth>,
#[serde(rename = "passwordAuth", default, skip_serializing_if = "Option::is_none")]
pub password_auth: Option<auth_config::PasswordAuth>,
}
impl AuthConfig {
pub fn new() -> Self {
Self::default()
}
}
pub mod auth_config {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "ActiveDirectoryAuth")]
pub enum ActiveDirectoryAuth {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for ActiveDirectoryAuth {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for ActiveDirectoryAuth {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for ActiveDirectoryAuth {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Enabled => serializer.serialize_unit_variant("ActiveDirectoryAuth", 0u32, "enabled"),
Self::Disabled => serializer.serialize_unit_variant("ActiveDirectoryAuth", 1u32, "disabled"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "PasswordAuth")]
pub enum PasswordAuth {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for PasswordAuth {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for PasswordAuth {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for PasswordAuth {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Enabled => serializer.serialize_unit_variant("PasswordAuth", 0u32, "enabled"),
Self::Disabled => serializer.serialize_unit_variant("PasswordAuth", 1u32, "disabled"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "Represents a cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Cluster {
#[serde(flatten)]
pub tracked_resource: TrackedResource,
#[doc = "Properties of the cluster."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ClusterProperties>,
#[doc = "Describes the identity of the cluster."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub identity: Option<IdentityProperties>,
}
impl Cluster {
pub fn new(tracked_resource: TrackedResource) -> Self {
Self {
tracked_resource,
properties: None,
identity: None,
}
}
}
#[doc = "A list of cluster configurations."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ClusterConfigurationListResult {
#[doc = "The list of cluster configurations."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<Configuration>,
#[doc = "Link to retrieve next page of results."]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for ClusterConfigurationListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
self.next_link.clone().filter(|value| !value.is_empty())
}
}
impl ClusterConfigurationListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Represents a cluster for update."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ClusterForUpdate {
#[doc = "The properties used to update a cluster."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ClusterPropertiesForUpdate>,
#[doc = "Describes the identity of the cluster."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub identity: Option<IdentityProperties>,
#[doc = "Application-specific metadata in the form of key-value pairs."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
}
impl ClusterForUpdate {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "A list of clusters."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ClusterListResult {
#[doc = "The list of clusters"]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<Cluster>,
#[doc = "The link used to get the next page of cluster list."]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for ClusterListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
self.next_link.clone().filter(|value| !value.is_empty())
}
}
impl ClusterListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Properties of the cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ClusterProperties {
#[doc = "Indicates whether the cluster was created using AAD authentication."]
#[serde(rename = "aadAuthEnabled", default, skip_serializing_if = "Option::is_none")]
pub aad_auth_enabled: Option<cluster_properties::AadAuthEnabled>,
#[doc = "The administrator's login name of the servers in the cluster."]
#[serde(rename = "administratorLogin", default, skip_serializing_if = "Option::is_none")]
pub administrator_login: Option<String>,
#[doc = "The password of the administrator login. Required for creation."]
#[serde(rename = "administratorLoginPassword", default, skip_serializing_if = "Option::is_none")]
pub administrator_login_password: Option<String>,
#[doc = "The data encryption properties of a cluster."]
#[serde(rename = "dataEncryption", default, skip_serializing_if = "Option::is_none")]
pub data_encryption: Option<DataEncryption>,
#[doc = "Provisioning state of the cluster"]
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<String>,
#[doc = "A state of a cluster/server that is visible to user."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[doc = "The major PostgreSQL version on all cluster servers."]
#[serde(rename = "postgresqlVersion", default, skip_serializing_if = "Option::is_none")]
pub postgresql_version: Option<String>,
#[doc = "The Citus extension version on all cluster servers."]
#[serde(rename = "citusVersion", default, skip_serializing_if = "Option::is_none")]
pub citus_version: Option<String>,
#[doc = "Schedule settings for regular cluster updates."]
#[serde(rename = "maintenanceWindow", default, skip_serializing_if = "Option::is_none")]
pub maintenance_window: Option<MaintenanceWindow>,
#[doc = "Preferred primary availability zone (AZ) for all cluster servers."]
#[serde(rename = "preferredPrimaryZone", default, skip_serializing_if = "Option::is_none")]
pub preferred_primary_zone: Option<String>,
#[doc = "If distributed tables are placed on coordinator or not. Should be set to 'true' on single node clusters. Requires shard rebalancing after value is changed."]
#[serde(rename = "enableShardsOnCoordinator", default, skip_serializing_if = "Option::is_none")]
pub enable_shards_on_coordinator: Option<bool>,
#[doc = "If high availability (HA) is enabled or not for the cluster."]
#[serde(rename = "enableHa", default, skip_serializing_if = "Option::is_none")]
pub enable_ha: Option<bool>,
#[doc = "The edition of a coordinator server (default: GeneralPurpose). Required for creation."]
#[serde(rename = "coordinatorServerEdition", default, skip_serializing_if = "Option::is_none")]
pub coordinator_server_edition: Option<String>,
#[doc = "The storage of a server in MB. Required for creation. See https://learn.microsoft.com/azure/cosmos-db/postgresql/resources-compute for more information."]
#[serde(rename = "coordinatorStorageQuotaInMb", default, skip_serializing_if = "Option::is_none")]
pub coordinator_storage_quota_in_mb: Option<i32>,
#[doc = "The vCores count of a server (max: 96). Required for creation. See https://learn.microsoft.com/azure/cosmos-db/postgresql/resources-compute for more information."]
#[serde(rename = "coordinatorVCores", default, skip_serializing_if = "Option::is_none")]
pub coordinator_v_cores: Option<i32>,
#[doc = "If public access is enabled on coordinator."]
#[serde(rename = "coordinatorEnablePublicIpAccess", default, skip_serializing_if = "Option::is_none")]
pub coordinator_enable_public_ip_access: Option<bool>,
#[doc = "The edition of a node server (default: MemoryOptimized)."]
#[serde(rename = "nodeServerEdition", default, skip_serializing_if = "Option::is_none")]
pub node_server_edition: Option<String>,
#[doc = "Worker node count of the cluster. When node count is 0, it represents a single node configuration with the ability to create distributed tables on that node. 2 or more worker nodes represent multi-node configuration. Node count value cannot be 1. Required for creation."]
#[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
pub node_count: Option<i32>,
#[doc = "The storage in MB on each worker node. See https://learn.microsoft.com/azure/cosmos-db/postgresql/resources-compute for more information."]
#[serde(rename = "nodeStorageQuotaInMb", default, skip_serializing_if = "Option::is_none")]
pub node_storage_quota_in_mb: Option<i32>,
#[doc = "The compute in vCores on each worker node (max: 104). See https://learn.microsoft.com/azure/cosmos-db/postgresql/resources-compute for more information."]
#[serde(rename = "nodeVCores", default, skip_serializing_if = "Option::is_none")]
pub node_v_cores: Option<i32>,
#[doc = "If public access is enabled on worker nodes."]
#[serde(rename = "nodeEnablePublicIpAccess", default, skip_serializing_if = "Option::is_none")]
pub node_enable_public_ip_access: Option<bool>,
#[doc = "The list of server names in the cluster"]
#[serde(
rename = "serverNames",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub server_names: Vec<ServerNameItem>,
#[doc = "The resource id of source cluster for read replica clusters."]
#[serde(rename = "sourceResourceId", default, skip_serializing_if = "Option::is_none")]
pub source_resource_id: Option<String>,
#[doc = "The Azure region of source cluster for read replica clusters."]
#[serde(rename = "sourceLocation", default, skip_serializing_if = "Option::is_none")]
pub source_location: Option<String>,
#[doc = "Indicates whether the cluster was created with a password or using AAD authentication."]
#[serde(rename = "passwordEnabled", default, skip_serializing_if = "Option::is_none")]
pub password_enabled: Option<cluster_properties::PasswordEnabled>,
#[doc = "Date and time in UTC (ISO8601 format) for cluster restore."]
#[serde(rename = "pointInTimeUTC", default, with = "azure_core::date::rfc3339::option")]
pub point_in_time_utc: Option<::time::OffsetDateTime>,
#[doc = "The array of read replica clusters."]
#[serde(
rename = "readReplicas",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub read_replicas: Vec<String>,
#[doc = "The earliest restore point time (ISO8601 format) for the cluster."]
#[serde(rename = "earliestRestoreTime", default, with = "azure_core::date::rfc3339::option")]
pub earliest_restore_time: Option<::time::OffsetDateTime>,
#[doc = "The private endpoint connections for a cluster."]
#[serde(
rename = "privateEndpointConnections",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub private_endpoint_connections: Vec<SimplePrivateEndpointConnection>,
#[doc = "The database name of the cluster. Only one database per cluster is supported."]
#[serde(rename = "databaseName", default, skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[doc = "If cluster backup is stored in another Azure region in addition to the copy of the backup stored in the cluster's region. Enabled only at the time of cluster creation."]
#[serde(rename = "enableGeoBackup", default, skip_serializing_if = "Option::is_none")]
pub enable_geo_backup: Option<bool>,
#[doc = "Authentication configuration of a cluster."]
#[serde(rename = "authConfig", default, skip_serializing_if = "Option::is_none")]
pub auth_config: Option<AuthConfig>,
}
impl ClusterProperties {
pub fn new() -> Self {
Self::default()
}
}
pub mod cluster_properties {
use super::*;
#[doc = "Indicates whether the cluster was created using AAD authentication."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "AadAuthEnabled")]
pub enum AadAuthEnabled {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for AadAuthEnabled {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for AadAuthEnabled {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for AadAuthEnabled {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Enabled => serializer.serialize_unit_variant("AadAuthEnabled", 0u32, "enabled"),
Self::Disabled => serializer.serialize_unit_variant("AadAuthEnabled", 1u32, "disabled"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Indicates whether the cluster was created with a password or using AAD authentication."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "PasswordEnabled")]
pub enum PasswordEnabled {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for PasswordEnabled {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for PasswordEnabled {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for PasswordEnabled {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Enabled => serializer.serialize_unit_variant("PasswordEnabled", 0u32, "enabled"),
Self::Disabled => serializer.serialize_unit_variant("PasswordEnabled", 1u32, "disabled"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "The properties used to update a cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ClusterPropertiesForUpdate {
#[doc = "The password of the administrator login. Each cluster is created with pre-defined administrative role called ‘citus’.\u{202f}"]
#[serde(rename = "administratorLoginPassword", default, skip_serializing_if = "Option::is_none")]
pub administrator_login_password: Option<String>,
#[doc = "The major PostgreSQL version on all cluster servers."]
#[serde(rename = "postgresqlVersion", default, skip_serializing_if = "Option::is_none")]
pub postgresql_version: Option<String>,
#[doc = "The Citus extension version on all cluster servers."]
#[serde(rename = "citusVersion", default, skip_serializing_if = "Option::is_none")]
pub citus_version: Option<String>,
#[doc = "If distributed tables are placed on coordinator or not. Should be set to 'true' on single node clusters. Requires shard rebalancing after value is changed."]
#[serde(rename = "enableShardsOnCoordinator", default, skip_serializing_if = "Option::is_none")]
pub enable_shards_on_coordinator: Option<bool>,
#[doc = "If high availability (HA) is enabled or not for the cluster."]
#[serde(rename = "enableHa", default, skip_serializing_if = "Option::is_none")]
pub enable_ha: Option<bool>,
#[doc = "Preferred primary availability zone (AZ) for all cluster servers."]
#[serde(rename = "preferredPrimaryZone", default, skip_serializing_if = "Option::is_none")]
pub preferred_primary_zone: Option<String>,
#[doc = "The edition of the coordinator (default: GeneralPurpose)."]
#[serde(rename = "coordinatorServerEdition", default, skip_serializing_if = "Option::is_none")]
pub coordinator_server_edition: Option<String>,
#[doc = "The storage of the coordinator in MB."]
#[serde(rename = "coordinatorStorageQuotaInMb", default, skip_serializing_if = "Option::is_none")]
pub coordinator_storage_quota_in_mb: Option<i32>,
#[doc = "The vCores count of the coordinator (max: 96)."]
#[serde(rename = "coordinatorVCores", default, skip_serializing_if = "Option::is_none")]
pub coordinator_v_cores: Option<i32>,
#[doc = "If public access is enabled on coordinator."]
#[serde(rename = "coordinatorEnablePublicIpAccess", default, skip_serializing_if = "Option::is_none")]
pub coordinator_enable_public_ip_access: Option<bool>,
#[doc = "The edition of a node (default: MemoryOptimized)."]
#[serde(rename = "nodeServerEdition", default, skip_serializing_if = "Option::is_none")]
pub node_server_edition: Option<String>,
#[doc = "Worker node count of the cluster. When node count is 0, it represents a single node configuration with the ability to create distributed tables on that node. 2 or more worker nodes represent multi-node configuration. Node count value cannot be 1."]
#[serde(rename = "nodeCount", default, skip_serializing_if = "Option::is_none")]
pub node_count: Option<i32>,
#[doc = "The storage in MB on each worker node."]
#[serde(rename = "nodeStorageQuotaInMb", default, skip_serializing_if = "Option::is_none")]
pub node_storage_quota_in_mb: Option<i32>,
#[doc = "The compute in vCores on each worker node (max: 104)."]
#[serde(rename = "nodeVCores", default, skip_serializing_if = "Option::is_none")]
pub node_v_cores: Option<i32>,
#[doc = "If public access is enabled on worker nodes."]
#[serde(rename = "nodeEnablePublicIpAccess", default, skip_serializing_if = "Option::is_none")]
pub node_enable_public_ip_access: Option<bool>,
#[doc = "Schedule settings for regular cluster updates."]
#[serde(rename = "maintenanceWindow", default, skip_serializing_if = "Option::is_none")]
pub maintenance_window: Option<MaintenanceWindow>,
}
impl ClusterPropertiesForUpdate {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Represents a server in a cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ClusterServer {
#[serde(flatten)]
pub proxy_resource: ProxyResource,
#[doc = "The properties of a server in cluster."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ClusterServerProperties>,
}
impl ClusterServer {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "A list of servers in a cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ClusterServerListResult {
#[doc = "The list of servers in a cluster."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<ClusterServer>,
}
impl azure_core::Continuable for ClusterServerListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
None
}
}
impl ClusterServerListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The properties of a server in cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ClusterServerProperties {
#[serde(flatten)]
pub server_properties: ServerProperties,
#[doc = "The fully qualified domain name of a server."]
#[serde(rename = "fullyQualifiedDomainName", default, skip_serializing_if = "Option::is_none")]
pub fully_qualified_domain_name: Option<String>,
#[doc = "The role of a server."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub role: Option<ServerRole>,
#[doc = "A state of a cluster/server that is visible to user."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[doc = "A state of HA feature for the cluster."]
#[serde(rename = "haState", default, skip_serializing_if = "Option::is_none")]
pub ha_state: Option<String>,
#[doc = "Availability Zone information of the server."]
#[serde(rename = "availabilityZone", default, skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[doc = "The major PostgreSQL version of server."]
#[serde(rename = "postgresqlVersion", default, skip_serializing_if = "Option::is_none")]
pub postgresql_version: Option<String>,
#[doc = "The Citus extension version of server."]
#[serde(rename = "citusVersion", default, skip_serializing_if = "Option::is_none")]
pub citus_version: Option<String>,
}
impl ClusterServerProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Represents configuration details for coordinator and node."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Configuration {
#[serde(flatten)]
pub proxy_resource: ProxyResource,
#[doc = "The properties of configuration."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ConfigurationProperties>,
}
impl Configuration {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The properties of configuration."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConfigurationProperties {
#[doc = "Description of the configuration."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[doc = "Data type of the configuration."]
#[serde(rename = "dataType", default, skip_serializing_if = "Option::is_none")]
pub data_type: Option<configuration_properties::DataType>,
#[doc = "Allowed values of the configuration."]
#[serde(rename = "allowedValues", default, skip_serializing_if = "Option::is_none")]
pub allowed_values: Option<String>,
#[doc = "If configuration change requires restart."]
#[serde(rename = "requiresRestart", default, skip_serializing_if = "Option::is_none")]
pub requires_restart: Option<bool>,
#[doc = "The list of server role group configuration values."]
#[serde(rename = "serverRoleGroupConfigurations")]
pub server_role_group_configurations: Vec<ServerRoleGroupConfiguration>,
#[doc = "The current provisioning state."]
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<ProvisioningState>,
}
impl ConfigurationProperties {
pub fn new(server_role_group_configurations: Vec<ServerRoleGroupConfiguration>) -> Self {
Self {
description: None,
data_type: None,
allowed_values: None,
requires_restart: None,
server_role_group_configurations,
provisioning_state: None,
}
}
}
pub mod configuration_properties {
use super::*;
#[doc = "Data type of the configuration."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "DataType")]
pub enum DataType {
Boolean,
Numeric,
Integer,
Enumeration,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for DataType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for DataType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for DataType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Boolean => serializer.serialize_unit_variant("DataType", 0u32, "Boolean"),
Self::Numeric => serializer.serialize_unit_variant("DataType", 1u32, "Numeric"),
Self::Integer => serializer.serialize_unit_variant("DataType", 2u32, "Integer"),
Self::Enumeration => serializer.serialize_unit_variant("DataType", 3u32, "Enumeration"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "The data encryption properties of a cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DataEncryption {
#[doc = "URI for the key in keyvault for data encryption of the primary server."]
#[serde(rename = "primaryKeyUri", default, skip_serializing_if = "Option::is_none")]
pub primary_key_uri: Option<String>,
#[doc = "Resource Id for the User assigned identity to be used for data encryption of the primary server."]
#[serde(rename = "primaryUserAssignedIdentityId", default, skip_serializing_if = "Option::is_none")]
pub primary_user_assigned_identity_id: Option<String>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<data_encryption::Type>,
}
impl DataEncryption {
pub fn new() -> Self {
Self::default()
}
}
pub mod data_encryption {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "Type")]
pub enum Type {
AzureKeyVault,
SystemAssigned,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for Type {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for Type {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for Type {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::AzureKeyVault => serializer.serialize_unit_variant("Type", 0u32, "AzureKeyVault"),
Self::SystemAssigned => serializer.serialize_unit_variant("Type", 1u32, "SystemAssigned"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "The resource management error additional info."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ErrorAdditionalInfo {
#[doc = "The additional info type."]
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[doc = "The additional info."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub info: Option<serde_json::Value>,
}
impl ErrorAdditionalInfo {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The error detail."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ErrorDetail {
#[doc = "The error code."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[doc = "The error message."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[doc = "The error target."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
#[doc = "The error details."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub details: Vec<ErrorDetail>,
#[doc = "The error additional info."]
#[serde(
rename = "additionalInfo",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub additional_info: Vec<ErrorAdditionalInfo>,
}
impl ErrorDetail {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.)."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ErrorResponse {
#[doc = "The error detail."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorDetail>,
}
impl azure_core::Continuable for ErrorResponse {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
None
}
}
impl ErrorResponse {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Represents a cluster firewall rule."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FirewallRule {
#[serde(flatten)]
pub proxy_resource: ProxyResource,
#[doc = "The properties of a cluster firewall rule."]
pub properties: FirewallRuleProperties,
}
impl FirewallRule {
pub fn new(properties: FirewallRuleProperties) -> Self {
Self {
proxy_resource: ProxyResource::default(),
properties,
}
}
}
#[doc = "A list of firewall rules."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct FirewallRuleListResult {
#[doc = "The list of firewall rules in a cluster."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<FirewallRule>,
}
impl azure_core::Continuable for FirewallRuleListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
None
}
}
impl FirewallRuleListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The properties of a cluster firewall rule."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FirewallRuleProperties {
#[doc = "The start IP address of the cluster firewall rule. Must be IPv4 format."]
#[serde(rename = "startIpAddress")]
pub start_ip_address: String,
#[doc = "The end IP address of the cluster firewall rule. Must be IPv4 format."]
#[serde(rename = "endIpAddress")]
pub end_ip_address: String,
#[doc = "The current provisioning state."]
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<ProvisioningState>,
}
impl FirewallRuleProperties {
pub fn new(start_ip_address: String, end_ip_address: String) -> Self {
Self {
start_ip_address,
end_ip_address,
provisioning_state: None,
}
}
}
#[doc = "Describes the identity of the cluster."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct IdentityProperties {
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<identity_properties::Type>,
#[doc = "The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests."]
#[serde(rename = "userAssignedIdentities", default, skip_serializing_if = "Option::is_none")]
pub user_assigned_identities: Option<UserAssignedIdentities>,
}
impl IdentityProperties {
pub fn new() -> Self {
Self::default()
}
}
pub mod identity_properties {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "Type")]
pub enum Type {
UserAssigned,
SystemAssigned,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for Type {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for Type {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for Type {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::UserAssigned => serializer.serialize_unit_variant("Type", 0u32, "UserAssigned"),
Self::SystemAssigned => serializer.serialize_unit_variant("Type", 1u32, "SystemAssigned"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "Schedule settings for regular cluster updates."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MaintenanceWindow {
#[doc = "Indicates whether custom maintenance window is enabled or not."]
#[serde(rename = "customWindow", default, skip_serializing_if = "Option::is_none")]
pub custom_window: Option<String>,
#[doc = "Start hour within preferred day of the week for maintenance window."]
#[serde(rename = "startHour", default, skip_serializing_if = "Option::is_none")]
pub start_hour: Option<i32>,
#[doc = "Start minute within the start hour for maintenance window."]
#[serde(rename = "startMinute", default, skip_serializing_if = "Option::is_none")]
pub start_minute: Option<i32>,
#[doc = "Preferred day of the week for maintenance window."]
#[serde(rename = "dayOfWeek", default, skip_serializing_if = "Option::is_none")]
pub day_of_week: Option<i32>,
}
impl MaintenanceWindow {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Represents cluster name availability."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct NameAvailability {
#[doc = "Error message."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[doc = "Indicates whether the cluster name is available."]
#[serde(rename = "nameAvailable", default, skip_serializing_if = "Option::is_none")]
pub name_available: Option<bool>,
#[doc = "Name of the cluster."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[doc = "Type of the cluster."]
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
impl NameAvailability {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Request from client to check cluster name availability."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NameAvailabilityRequest {
#[doc = "Cluster name to verify."]
pub name: String,
#[doc = "Resource type used for verification."]
#[serde(rename = "type")]
pub type_: name_availability_request::Type,
}
impl NameAvailabilityRequest {
pub fn new(name: String, type_: name_availability_request::Type) -> Self {
Self { name, type_ }
}
}
pub mod name_availability_request {
use super::*;
#[doc = "Resource type used for verification."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Type {
#[serde(rename = "Microsoft.DBforPostgreSQL/serverGroupsv2")]
MicrosoftDBforPostgreSqlServerGroupsv2,
}
}
#[doc = "REST API operation definition."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Operation {
#[doc = "The name of the operation being performed on this particular object."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[doc = "Display metadata associated with the operation."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub display: Option<OperationDisplay>,
#[doc = "Indicates whether the operation is a data action."]
#[serde(rename = "isDataAction", default, skip_serializing_if = "Option::is_none")]
pub is_data_action: Option<bool>,
#[doc = "The intended executor of the operation."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub origin: Option<operation::Origin>,
#[doc = "Additional descriptions for the operation."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<serde_json::Value>,
}
impl Operation {
pub fn new() -> Self {
Self::default()
}
}
pub mod operation {
use super::*;
#[doc = "The intended executor of the operation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "Origin")]
pub enum Origin {
NotSpecified,
#[serde(rename = "user")]
User,
#[serde(rename = "system")]
System,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for Origin {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for Origin {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for Origin {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::NotSpecified => serializer.serialize_unit_variant("Origin", 0u32, "NotSpecified"),
Self::User => serializer.serialize_unit_variant("Origin", 1u32, "user"),
Self::System => serializer.serialize_unit_variant("Origin", 2u32, "system"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "Display metadata associated with the operation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationDisplay {
#[doc = "Operation resource provider name."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider: Option<String>,
#[doc = "Resource on which the operation is performed."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
#[doc = "Localized friendly name for the operation."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub operation: Option<String>,
#[doc = "Operation description."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
impl OperationDisplay {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "A list of resource provider operations."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationListResult {
#[doc = "Collection of available operation details."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<Operation>,
#[doc = "URL client should use to fetch the next page (per server side paging).\r\nIt's null for now, added for future use."]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for OperationListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
None
}
}
impl OperationListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The private endpoint resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateEndpoint {
#[doc = "The ARM identifier for private endpoint."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
impl PrivateEndpoint {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The private endpoint connection resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateEndpointConnection {
#[serde(flatten)]
pub resource: Resource,
#[doc = "Properties of the private endpoint connection."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<PrivateEndpointConnectionProperties>,
}
impl PrivateEndpointConnection {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "List of private endpoint connections associated with the specified resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateEndpointConnectionListResult {
#[doc = "Array of private endpoint connections."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<PrivateEndpointConnection>,
}
impl azure_core::Continuable for PrivateEndpointConnectionListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
None
}
}
impl PrivateEndpointConnectionListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Properties of the private endpoint connection."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PrivateEndpointConnectionProperties {
#[doc = "The group ids for the private endpoint resource."]
#[serde(
rename = "groupIds",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub group_ids: Vec<String>,
#[doc = "The private endpoint resource."]
#[serde(rename = "privateEndpoint", default, skip_serializing_if = "Option::is_none")]
pub private_endpoint: Option<PrivateEndpoint>,
#[doc = "A collection of information about the state of the connection between service consumer and provider."]
#[serde(rename = "privateLinkServiceConnectionState")]
pub private_link_service_connection_state: PrivateLinkServiceConnectionState,
#[doc = "The current provisioning state."]
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<PrivateEndpointConnectionProvisioningState>,
}
impl PrivateEndpointConnectionProperties {
pub fn new(private_link_service_connection_state: PrivateLinkServiceConnectionState) -> Self {
Self {
group_ids: Vec::new(),
private_endpoint: None,
private_link_service_connection_state,
provisioning_state: None,
}
}
}
#[doc = "The current provisioning state."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "PrivateEndpointConnectionProvisioningState")]
pub enum PrivateEndpointConnectionProvisioningState {
Succeeded,
Creating,
Deleting,
Failed,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for PrivateEndpointConnectionProvisioningState {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for PrivateEndpointConnectionProvisioningState {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for PrivateEndpointConnectionProvisioningState {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Succeeded => serializer.serialize_unit_variant("PrivateEndpointConnectionProvisioningState", 0u32, "Succeeded"),
Self::Creating => serializer.serialize_unit_variant("PrivateEndpointConnectionProvisioningState", 1u32, "Creating"),
Self::Deleting => serializer.serialize_unit_variant("PrivateEndpointConnectionProvisioningState", 2u32, "Deleting"),
Self::Failed => serializer.serialize_unit_variant("PrivateEndpointConnectionProvisioningState", 3u32, "Failed"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "The properties in private endpoint connection"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateEndpointConnectionSimpleProperties {
#[doc = "Property to represent resource id of the private endpoint."]
#[serde(rename = "privateEndpoint", default, skip_serializing_if = "Option::is_none")]
pub private_endpoint: Option<PrivateEndpointProperty>,
#[doc = "Group ids of the private endpoint connection."]
#[serde(
rename = "groupIds",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub group_ids: Vec<String>,
#[doc = "A collection of information about the state of the connection between service consumer and provider."]
#[serde(rename = "privateLinkServiceConnectionState", default, skip_serializing_if = "Option::is_none")]
pub private_link_service_connection_state: Option<PrivateLinkServiceConnectionState>,
}
impl PrivateEndpointConnectionSimpleProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Property to represent resource id of the private endpoint."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateEndpointProperty {
#[doc = "Resource id of the private endpoint."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
impl PrivateEndpointProperty {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The private endpoint connection status."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "PrivateEndpointServiceConnectionStatus")]
pub enum PrivateEndpointServiceConnectionStatus {
Pending,
Approved,
Rejected,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for PrivateEndpointServiceConnectionStatus {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for PrivateEndpointServiceConnectionStatus {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for PrivateEndpointServiceConnectionStatus {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Pending => serializer.serialize_unit_variant("PrivateEndpointServiceConnectionStatus", 0u32, "Pending"),
Self::Approved => serializer.serialize_unit_variant("PrivateEndpointServiceConnectionStatus", 1u32, "Approved"),
Self::Rejected => serializer.serialize_unit_variant("PrivateEndpointServiceConnectionStatus", 2u32, "Rejected"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "A private link resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateLinkResource {
#[serde(flatten)]
pub resource: Resource,
#[doc = "Properties of a private link resource."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<PrivateLinkResourceProperties>,
}
impl PrivateLinkResource {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "A list of private link resources."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateLinkResourceListResult {
#[doc = "Array of private link resources"]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<PrivateLinkResource>,
}
impl azure_core::Continuable for PrivateLinkResourceListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
None
}
}
impl PrivateLinkResourceListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Properties of a private link resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateLinkResourceProperties {
#[doc = "The private link resource group id."]
#[serde(rename = "groupId", default, skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
#[doc = "The private link resource required member names."]
#[serde(
rename = "requiredMembers",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub required_members: Vec<String>,
#[doc = "The private link resource private link DNS zone name."]
#[serde(
rename = "requiredZoneNames",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub required_zone_names: Vec<String>,
}
impl PrivateLinkResourceProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "A collection of information about the state of the connection between service consumer and provider."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrivateLinkServiceConnectionState {
#[doc = "The private endpoint connection status."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<PrivateEndpointServiceConnectionStatus>,
#[doc = "The reason for approval/rejection of the connection."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[doc = "A message indicating if changes on the service provider require any updates on the consumer."]
#[serde(rename = "actionsRequired", default, skip_serializing_if = "Option::is_none")]
pub actions_required: Option<String>,
}
impl PrivateLinkServiceConnectionState {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Request from client to promote geo-redundant replica"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PromoteRequest {
#[doc = "Boolean property to enable geo-redundant replica promotion."]
#[serde(rename = "enableGeoBackup", default, skip_serializing_if = "Option::is_none")]
pub enable_geo_backup: Option<bool>,
}
impl PromoteRequest {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The current provisioning state."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "ProvisioningState")]
pub enum ProvisioningState {
Succeeded,
Canceled,
InProgress,
Failed,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for ProvisioningState {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for ProvisioningState {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for ProvisioningState {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Succeeded => serializer.serialize_unit_variant("ProvisioningState", 0u32, "Succeeded"),
Self::Canceled => serializer.serialize_unit_variant("ProvisioningState", 1u32, "Canceled"),
Self::InProgress => serializer.serialize_unit_variant("ProvisioningState", 2u32, "InProgress"),
Self::Failed => serializer.serialize_unit_variant("ProvisioningState", 3u32, "Failed"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ProxyResource {
#[serde(flatten)]
pub resource: Resource,
}
impl ProxyResource {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Common fields that are returned in the response for all Azure Resource Manager resources"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Resource {
#[doc = "Fully qualified resource ID for the resource. E.g. \"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}\""]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[doc = "The name of the resource"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[doc = "The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or \"Microsoft.Storage/storageAccounts\""]
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[doc = "Metadata pertaining to creation and last modification of the resource."]
#[serde(rename = "systemData", default, skip_serializing_if = "Option::is_none")]
pub system_data: Option<SystemData>,
}
impl Resource {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Represents a cluster role."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Role {
#[serde(flatten)]
pub proxy_resource: ProxyResource,
#[doc = "The properties of a cluster role."]
pub properties: RoleProperties,
}
impl Role {
pub fn new(properties: RoleProperties) -> Self {
Self {
proxy_resource: ProxyResource::default(),
properties,
}
}
}
#[doc = "A list of roles."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct RoleListResult {
#[doc = "The list of roles in a cluster."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<Role>,
}
impl azure_core::Continuable for RoleListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
None
}
}
impl RoleListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The properties of a cluster role."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct RoleProperties {
#[serde(rename = "roleType", default, skip_serializing_if = "Option::is_none")]
pub role_type: Option<role_properties::RoleType>,
#[doc = "The password of the cluster role. If an identity is used, password will not be required."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "externalIdentity", default, skip_serializing_if = "Option::is_none")]
pub external_identity: Option<role_properties::ExternalIdentity>,
#[doc = "The current provisioning state."]
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<ProvisioningState>,
}
impl RoleProperties {
pub fn new() -> Self {
Self::default()
}
}
pub mod role_properties {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "RoleType")]
pub enum RoleType {
#[serde(rename = "user")]
User,
#[serde(rename = "admin")]
Admin,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for RoleType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for RoleType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for RoleType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::User => serializer.serialize_unit_variant("RoleType", 0u32, "user"),
Self::Admin => serializer.serialize_unit_variant("RoleType", 1u32, "admin"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
impl Default for RoleType {
fn default() -> Self {
Self::User
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExternalIdentity {
#[serde(rename = "objectId")]
pub object_id: String,
#[serde(rename = "principalType")]
pub principal_type: external_identity::PrincipalType,
#[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
pub tenant_id: Option<String>,
}
impl ExternalIdentity {
pub fn new(object_id: String, principal_type: external_identity::PrincipalType) -> Self {
Self {
object_id,
principal_type,
tenant_id: None,
}
}
}
pub mod external_identity {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "PrincipalType")]
pub enum PrincipalType {
#[serde(rename = "user")]
User,
#[serde(rename = "servicePrincipal")]
ServicePrincipal,
#[serde(rename = "group")]
Group,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for PrincipalType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for PrincipalType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for PrincipalType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::User => serializer.serialize_unit_variant("PrincipalType", 0u32, "user"),
Self::ServicePrincipal => serializer.serialize_unit_variant("PrincipalType", 1u32, "servicePrincipal"),
Self::Group => serializer.serialize_unit_variant("PrincipalType", 2u32, "group"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
}
#[doc = "Represents a configuration."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ServerConfiguration {
#[serde(flatten)]
pub proxy_resource: ProxyResource,
#[doc = "The properties of a configuration."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ServerConfigurationProperties>,
}
impl ServerConfiguration {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "A list of server configurations."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ServerConfigurationListResult {
#[doc = "The list of server configurations."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<ServerConfiguration>,
#[doc = "Link to retrieve next page of results."]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for ServerConfigurationListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
self.next_link.clone().filter(|value| !value.is_empty())
}
}
impl ServerConfigurationListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The properties of a configuration."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ServerConfigurationProperties {
#[doc = "Value of the configuration."]
pub value: String,
#[doc = "Source of the configuration."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
#[doc = "Description of the configuration."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[doc = "Default value of the configuration."]
#[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
pub default_value: Option<String>,
#[doc = "Data type of the configuration."]
#[serde(rename = "dataType", default, skip_serializing_if = "Option::is_none")]
pub data_type: Option<server_configuration_properties::DataType>,
#[doc = "Allowed values of the configuration."]
#[serde(rename = "allowedValues", default, skip_serializing_if = "Option::is_none")]
pub allowed_values: Option<String>,
#[doc = "If configuration change requires restart."]
#[serde(rename = "requiresRestart", default, skip_serializing_if = "Option::is_none")]
pub requires_restart: Option<bool>,
#[doc = "The current provisioning state."]
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<ProvisioningState>,
}
impl ServerConfigurationProperties {
pub fn new(value: String) -> Self {
Self {
value,
source: None,
description: None,
default_value: None,
data_type: None,
allowed_values: None,
requires_restart: None,
provisioning_state: None,
}
}
}
pub mod server_configuration_properties {
use super::*;
#[doc = "Data type of the configuration."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "DataType")]
pub enum DataType {
Boolean,
Numeric,
Integer,
Enumeration,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for DataType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for DataType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for DataType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Boolean => serializer.serialize_unit_variant("DataType", 0u32, "Boolean"),
Self::Numeric => serializer.serialize_unit_variant("DataType", 1u32, "Numeric"),
Self::Integer => serializer.serialize_unit_variant("DataType", 2u32, "Integer"),
Self::Enumeration => serializer.serialize_unit_variant("DataType", 3u32, "Enumeration"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "The name object for a server."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ServerNameItem {
#[doc = "The name of a server."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[doc = "The fully qualified domain name of a server."]
#[serde(rename = "fullyQualifiedDomainName", default, skip_serializing_if = "Option::is_none")]
pub fully_qualified_domain_name: Option<String>,
}
impl ServerNameItem {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The properties of a server."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ServerProperties {
#[doc = "The edition of a server."]
#[serde(rename = "serverEdition", default, skip_serializing_if = "Option::is_none")]
pub server_edition: Option<String>,
#[doc = "The storage of a server in MB."]
#[serde(rename = "storageQuotaInMb", default, skip_serializing_if = "Option::is_none")]
pub storage_quota_in_mb: Option<i32>,
#[doc = "The vCores count of a server."]
#[serde(rename = "vCores", default, skip_serializing_if = "Option::is_none")]
pub v_cores: Option<i32>,
#[doc = "If high availability (HA) is enabled or not for the server."]
#[serde(rename = "enableHa", default, skip_serializing_if = "Option::is_none")]
pub enable_ha: Option<bool>,
#[doc = "If public access is enabled on server."]
#[serde(rename = "enablePublicIpAccess", default, skip_serializing_if = "Option::is_none")]
pub enable_public_ip_access: Option<bool>,
#[doc = "If server database is set to read-only by system maintenance depending on high disk space usage."]
#[serde(rename = "isReadOnly", default, skip_serializing_if = "Option::is_none")]
pub is_read_only: Option<bool>,
#[doc = "The administrator's login name of the servers in the cluster."]
#[serde(rename = "administratorLogin", default, skip_serializing_if = "Option::is_none")]
pub administrator_login: Option<String>,
}
impl ServerProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The role of a server."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "ServerRole")]
pub enum ServerRole {
Coordinator,
Worker,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for ServerRole {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for ServerRole {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for ServerRole {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Coordinator => serializer.serialize_unit_variant("ServerRole", 0u32, "Coordinator"),
Self::Worker => serializer.serialize_unit_variant("ServerRole", 1u32, "Worker"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Represents server role group configuration value."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ServerRoleGroupConfiguration {
#[doc = "The role of a server."]
pub role: ServerRole,
#[doc = "Value of the configuration."]
pub value: String,
#[doc = "Default value of the configuration."]
#[serde(rename = "defaultValue", default, skip_serializing_if = "Option::is_none")]
pub default_value: Option<String>,
#[doc = "Source of the configuration."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
}
impl ServerRoleGroupConfiguration {
pub fn new(role: ServerRole, value: String) -> Self {
Self {
role,
value,
default_value: None,
source: None,
}
}
}
#[doc = "A private endpoint connection."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SimplePrivateEndpointConnection {
#[serde(flatten)]
pub proxy_resource: ProxyResource,
#[doc = "The properties in private endpoint connection"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<PrivateEndpointConnectionSimpleProperties>,
}
impl SimplePrivateEndpointConnection {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TrackedResource {
#[serde(flatten)]
pub resource: Resource,
#[doc = "Resource tags."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[doc = "The geo-location where the resource lives"]
pub location: String,
}
impl TrackedResource {
pub fn new(location: String) -> Self {
Self {
resource: Resource::default(),
tags: None,
location,
}
}
}
#[doc = "The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UserAssignedIdentities {}
impl UserAssignedIdentities {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "User assigned identity properties"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UserAssignedIdentity {
#[doc = "The principal ID of the assigned identity."]
#[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
pub principal_id: Option<String>,
#[doc = "The client ID of the assigned identity."]
#[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
}
impl UserAssignedIdentity {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Metadata pertaining to creation and last modification of the resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SystemData {
#[doc = "The identity that created the resource."]
#[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[doc = "The type of identity that created the resource."]
#[serde(rename = "createdByType", default, skip_serializing_if = "Option::is_none")]
pub created_by_type: Option<system_data::CreatedByType>,
#[doc = "The timestamp of resource creation (UTC)."]
#[serde(rename = "createdAt", default, with = "azure_core::date::rfc3339::option")]
pub created_at: Option<::time::OffsetDateTime>,
#[doc = "The identity that last modified the resource."]
#[serde(rename = "lastModifiedBy", default, skip_serializing_if = "Option::is_none")]
pub last_modified_by: Option<String>,
#[doc = "The type of identity that last modified the resource."]
#[serde(rename = "lastModifiedByType", default, skip_serializing_if = "Option::is_none")]
pub last_modified_by_type: Option<system_data::LastModifiedByType>,
#[doc = "The timestamp of resource last modification (UTC)"]
#[serde(rename = "lastModifiedAt", default, with = "azure_core::date::rfc3339::option")]
pub last_modified_at: Option<::time::OffsetDateTime>,
}
impl SystemData {
pub fn new() -> Self {
Self::default()
}
}
pub mod system_data {
use super::*;
#[doc = "The type of identity that created the resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "CreatedByType")]
pub enum CreatedByType {
User,
Application,
ManagedIdentity,
Key,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for CreatedByType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for CreatedByType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for CreatedByType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::User => serializer.serialize_unit_variant("CreatedByType", 0u32, "User"),
Self::Application => serializer.serialize_unit_variant("CreatedByType", 1u32, "Application"),
Self::ManagedIdentity => serializer.serialize_unit_variant("CreatedByType", 2u32, "ManagedIdentity"),
Self::Key => serializer.serialize_unit_variant("CreatedByType", 3u32, "Key"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "The type of identity that last modified the resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "LastModifiedByType")]
pub enum LastModifiedByType {
User,
Application,
ManagedIdentity,
Key,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for LastModifiedByType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for LastModifiedByType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for LastModifiedByType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::User => serializer.serialize_unit_variant("LastModifiedByType", 0u32, "User"),
Self::Application => serializer.serialize_unit_variant("LastModifiedByType", 1u32, "Application"),
Self::ManagedIdentity => serializer.serialize_unit_variant("LastModifiedByType", 2u32, "ManagedIdentity"),
Self::Key => serializer.serialize_unit_variant("LastModifiedByType", 3u32, "Key"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}