#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::de::{value, Deserializer, IntoDeserializer};
use serde::{Deserialize, Serialize, Serializer};
use std::str::FromStr;
#[doc = "Describe the properties of a security assessment object reference (by key)"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AssignedAssessmentItem {
#[doc = "Unique key to a security assessment object"]
#[serde(rename = "assessmentKey", default, skip_serializing_if = "Option::is_none")]
pub assessment_key: Option<String>,
}
impl AssignedAssessmentItem {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Describe the properties of a of a standard assignments object reference"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AssignedStandardItem {
#[doc = "Full resourceId of the Microsoft.Security/standard object"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
impl AssignedStandardItem {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Describe the properties of a assignment attestation"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AttestationEvidence {
#[doc = "The description of the evidence"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[doc = "The source url of the evidence"]
#[serde(rename = "sourceUrl", default, skip_serializing_if = "Option::is_none")]
pub source_url: Option<String>,
}
impl AttestationEvidence {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Custom Recommendation"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct CustomRecommendation {
#[serde(flatten)]
pub resource: Resource,
#[doc = "describes the Custom Recommendation properties"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<CustomRecommendationProperties>,
#[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 CustomRecommendation {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "describes the Custom Recommendation properties"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct CustomRecommendationProperties {
#[doc = "KQL query representing the Recommendation results required."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub query: Option<String>,
#[doc = "List of all standard supported clouds."]
#[serde(
rename = "cloudProviders",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub cloud_providers: Vec<RecommendationSupportedCloud>,
#[doc = "The severity to relate to the assessments generated by this Recommendation."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub severity: Option<custom_recommendation_properties::Severity>,
#[doc = "The severity to relate to the assessments generated by this Recommendation."]
#[serde(rename = "securityIssue", default, skip_serializing_if = "Option::is_none")]
pub security_issue: Option<custom_recommendation_properties::SecurityIssue>,
#[doc = "The display name of the assessments generated by this Recommendation."]
#[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[doc = "The description to relate to the assessments generated by this Recommendation."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[doc = "The remediation description to relate to the assessments generated by this Recommendation."]
#[serde(rename = "remediationDescription", default, skip_serializing_if = "Option::is_none")]
pub remediation_description: Option<String>,
#[doc = "The assessment metadata key used when an assessment is generated for this Recommendation."]
#[serde(rename = "assessmentKey", default, skip_serializing_if = "Option::is_none")]
pub assessment_key: Option<String>,
}
impl CustomRecommendationProperties {
pub fn new() -> Self {
Self::default()
}
}
pub mod custom_recommendation_properties {
use super::*;
#[doc = "The severity to relate to the assessments generated by this Recommendation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "Severity")]
pub enum Severity {
High,
Medium,
Low,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for Severity {
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 Severity {
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 Severity {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::High => serializer.serialize_unit_variant("Severity", 0u32, "High"),
Self::Medium => serializer.serialize_unit_variant("Severity", 1u32, "Medium"),
Self::Low => serializer.serialize_unit_variant("Severity", 2u32, "Low"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "The severity to relate to the assessments generated by this Recommendation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "SecurityIssue")]
pub enum SecurityIssue {
Vulnerability,
ExcessivePermissions,
AnonymousAccess,
NetworkExposure,
TrafficEncryption,
BestPractices,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for SecurityIssue {
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 SecurityIssue {
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 SecurityIssue {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Vulnerability => serializer.serialize_unit_variant("SecurityIssue", 0u32, "Vulnerability"),
Self::ExcessivePermissions => serializer.serialize_unit_variant("SecurityIssue", 1u32, "ExcessivePermissions"),
Self::AnonymousAccess => serializer.serialize_unit_variant("SecurityIssue", 2u32, "AnonymousAccess"),
Self::NetworkExposure => serializer.serialize_unit_variant("SecurityIssue", 3u32, "NetworkExposure"),
Self::TrafficEncryption => serializer.serialize_unit_variant("SecurityIssue", 4u32, "TrafficEncryption"),
Self::BestPractices => serializer.serialize_unit_variant("SecurityIssue", 5u32, "BestPractices"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "A list of Custom Recommendations"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CustomRecommendationsList {
#[doc = "Collection of Custom Recommendations"]
pub value: Vec<CustomRecommendation>,
#[doc = "The link used to get the next page of operations."]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for CustomRecommendationsList {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
self.next_link.clone().filter(|value| !value.is_empty())
}
}
impl CustomRecommendationsList {
pub fn new(value: Vec<CustomRecommendation>) -> Self {
Self { value, next_link: None }
}
}
#[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 = "Describes properties of an assessment as related to the standard"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PartialAssessmentProperties {
#[doc = "The assessment key"]
#[serde(rename = "assessmentKey", default, skip_serializing_if = "Option::is_none")]
pub assessment_key: Option<String>,
}
impl PartialAssessmentProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The cloud that the recommendation is supported on."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "RecommendationSupportedCloud")]
pub enum RecommendationSupportedCloud {
Azure,
#[serde(rename = "AWS")]
Aws,
#[serde(rename = "GCP")]
Gcp,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for RecommendationSupportedCloud {
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 RecommendationSupportedCloud {
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 RecommendationSupportedCloud {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Azure => serializer.serialize_unit_variant("RecommendationSupportedCloud", 0u32, "Azure"),
Self::Aws => serializer.serialize_unit_variant("RecommendationSupportedCloud", 1u32, "AWS"),
Self::Gcp => serializer.serialize_unit_variant("RecommendationSupportedCloud", 2u32, "GCP"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Describes an Azure resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Resource {
#[doc = "Resource Id"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[doc = "Resource name"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[doc = "Resource type"]
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
impl Resource {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Security Standard on a resource"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SecurityStandard {
#[serde(flatten)]
pub resource: Resource,
#[doc = "Describes properties of a standard."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<StandardProperties>,
}
impl SecurityStandard {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Page of a Standard list"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SecurityStandardList {
#[doc = "Collection of standards in this page"]
pub value: Vec<SecurityStandard>,
#[doc = "The URI to fetch the next page"]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for SecurityStandardList {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
self.next_link.clone().filter(|value| !value.is_empty())
}
}
impl SecurityStandardList {
pub fn new(value: Vec<SecurityStandard>) -> Self {
Self { value, next_link: None }
}
}
#[doc = "Security Assignment on a resource group over a given scope"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct StandardAssignment {
#[serde(flatten)]
pub resource: Resource,
#[doc = "Describes the properties of a standardAssignment"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<StandardAssignmentProperties>,
}
impl StandardAssignment {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The standard assignment metadata"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct StandardAssignmentMetadata {
#[doc = "Standard assignment Created by object id (GUID)"]
#[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[doc = "Standard assignment creation date"]
#[serde(rename = "createdOn", default, with = "azure_core::date::rfc3339::option")]
pub created_on: Option<::time::OffsetDateTime>,
#[doc = "Standard assignment last updated by object id (GUID)"]
#[serde(rename = "lastUpdatedBy", default, skip_serializing_if = "Option::is_none")]
pub last_updated_by: Option<String>,
#[doc = "Standard assignment last update date"]
#[serde(rename = "lastUpdatedOn", default, with = "azure_core::date::rfc3339::option")]
pub last_updated_on: Option<::time::OffsetDateTime>,
}
impl StandardAssignmentMetadata {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Describes the properties of a standardAssignment"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct StandardAssignmentProperties {
#[doc = "Display name of the standardAssignment"]
#[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[doc = "Description of the standardAssignment"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[doc = "Describe the properties of a of a standard assignments object reference"]
#[serde(rename = "assignedStandard", default, skip_serializing_if = "Option::is_none")]
pub assigned_standard: Option<AssignedStandardItem>,
#[doc = "Expected effect of this assignment (Audit/Exempt/Attest)"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub effect: Option<standard_assignment_properties::Effect>,
#[doc = "Excluded scopes, filter out the descendants of the scope (on management scopes)"]
#[serde(
rename = "excludedScopes",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub excluded_scopes: Vec<String>,
#[doc = "Expiration date of this assignment as a full ISO date"]
#[serde(rename = "expiresOn", default, with = "azure_core::date::rfc3339::option")]
pub expires_on: Option<::time::OffsetDateTime>,
#[doc = "Additional data about assignment that has Exempt effect"]
#[serde(rename = "exemptionData", default, skip_serializing_if = "Option::is_none")]
pub exemption_data: Option<standard_assignment_properties::ExemptionData>,
#[doc = "Additional data about assignment that has Attest effect"]
#[serde(rename = "attestationData", default, skip_serializing_if = "Option::is_none")]
pub attestation_data: Option<standard_assignment_properties::AttestationData>,
#[doc = "The standard assignment metadata"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<StandardAssignmentMetadata>,
}
impl StandardAssignmentProperties {
pub fn new() -> Self {
Self::default()
}
}
pub mod standard_assignment_properties {
use super::*;
#[doc = "Expected effect of this assignment (Audit/Exempt/Attest)"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "Effect")]
pub enum Effect {
Audit,
Exempt,
Attest,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for Effect {
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 Effect {
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 Effect {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Audit => serializer.serialize_unit_variant("Effect", 0u32, "Audit"),
Self::Exempt => serializer.serialize_unit_variant("Effect", 1u32, "Exempt"),
Self::Attest => serializer.serialize_unit_variant("Effect", 2u32, "Attest"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Additional data about assignment that has Exempt effect"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ExemptionData {
#[doc = "Exemption category of this assignment"]
#[serde(rename = "exemptionCategory", default, skip_serializing_if = "Option::is_none")]
pub exemption_category: Option<exemption_data::ExemptionCategory>,
#[doc = "Describe the properties of a security assessment object reference (by key)"]
#[serde(rename = "assignedAssessment", default, skip_serializing_if = "Option::is_none")]
pub assigned_assessment: Option<AssignedAssessmentItem>,
}
impl ExemptionData {
pub fn new() -> Self {
Self::default()
}
}
pub mod exemption_data {
use super::*;
#[doc = "Exemption category of this assignment"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "ExemptionCategory")]
pub enum ExemptionCategory {
#[serde(rename = "waiver")]
Waiver,
#[serde(rename = "mitigated")]
Mitigated,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for ExemptionCategory {
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 ExemptionCategory {
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 ExemptionCategory {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Waiver => serializer.serialize_unit_variant("ExemptionCategory", 0u32, "waiver"),
Self::Mitigated => serializer.serialize_unit_variant("ExemptionCategory", 1u32, "mitigated"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "Additional data about assignment that has Attest effect"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AttestationData {
#[doc = "Attest category of this assignment"]
#[serde(rename = "complianceState", default, skip_serializing_if = "Option::is_none")]
pub compliance_state: Option<attestation_data::ComplianceState>,
#[doc = "Describe the properties of a security assessment object reference (by key)"]
#[serde(rename = "assignedAssessment", default, skip_serializing_if = "Option::is_none")]
pub assigned_assessment: Option<AssignedAssessmentItem>,
#[doc = "Attestation compliance date"]
#[serde(rename = "complianceDate", default, with = "azure_core::date::rfc3339::option")]
pub compliance_date: Option<::time::OffsetDateTime>,
#[doc = "Array of links to attestation evidence"]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub evidence: Vec<AttestationEvidence>,
}
impl AttestationData {
pub fn new() -> Self {
Self::default()
}
}
pub mod attestation_data {
use super::*;
#[doc = "Attest category of this assignment"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "ComplianceState")]
pub enum ComplianceState {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "compliant")]
Compliant,
#[serde(rename = "nonCompliant")]
NonCompliant,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for ComplianceState {
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 ComplianceState {
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 ComplianceState {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Unknown => serializer.serialize_unit_variant("ComplianceState", 0u32, "unknown"),
Self::Compliant => serializer.serialize_unit_variant("ComplianceState", 1u32, "compliant"),
Self::NonCompliant => serializer.serialize_unit_variant("ComplianceState", 2u32, "nonCompliant"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
}
#[doc = "Page of a standard assignment list"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct StandardAssignmentsList {
#[doc = "Collection of standardAssignments in this page"]
pub value: Vec<StandardAssignment>,
#[doc = "The URI to fetch the next page"]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for StandardAssignmentsList {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
self.next_link.clone().filter(|value| !value.is_empty())
}
}
impl StandardAssignmentsList {
pub fn new(value: Vec<StandardAssignment>) -> Self {
Self { value, next_link: None }
}
}
#[doc = "The standard metadata"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct StandardMetadata {
#[doc = "Standard Created by object id (GUID)"]
#[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[doc = "Standard creation date"]
#[serde(rename = "createdOn", default, with = "azure_core::date::rfc3339::option")]
pub created_on: Option<::time::OffsetDateTime>,
#[doc = "Standard last updated by object id (GUID)"]
#[serde(rename = "lastUpdatedBy", default, skip_serializing_if = "Option::is_none")]
pub last_updated_by: Option<String>,
#[doc = "Standard last update date"]
#[serde(rename = "lastUpdatedOn", default, with = "azure_core::date::rfc3339::option")]
pub last_updated_on: Option<::time::OffsetDateTime>,
}
impl StandardMetadata {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Describes properties of a standard."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct StandardProperties {
#[doc = "Display name of the standard, equivalent to the standardId"]
#[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[doc = "Standard type (Custom or Default or Compliance only currently)"]
#[serde(rename = "standardType", default, skip_serializing_if = "Option::is_none")]
pub standard_type: Option<standard_properties::StandardType>,
#[doc = "Description of the standard"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[doc = "List of assessment keys to apply to standard scope."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub assessments: Vec<PartialAssessmentProperties>,
#[doc = "List of all standard supported clouds."]
#[serde(
rename = "cloudProviders",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub cloud_providers: Vec<StandardSupportedCloud>,
#[doc = "The policy set definition id associated with the standard."]
#[serde(rename = "policySetDefinitionId", default, skip_serializing_if = "Option::is_none")]
pub policy_set_definition_id: Option<String>,
#[doc = "The standard metadata"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<StandardMetadata>,
}
impl StandardProperties {
pub fn new() -> Self {
Self::default()
}
}
pub mod standard_properties {
use super::*;
#[doc = "Standard type (Custom or Default or Compliance only currently)"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "StandardType")]
pub enum StandardType {
Custom,
Default,
Compliance,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for StandardType {
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 StandardType {
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 StandardType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Custom => serializer.serialize_unit_variant("StandardType", 0u32, "Custom"),
Self::Default => serializer.serialize_unit_variant("StandardType", 1u32, "Default"),
Self::Compliance => serializer.serialize_unit_variant("StandardType", 2u32, "Compliance"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "The cloud that the standard is supported on."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "StandardSupportedCloud")]
pub enum StandardSupportedCloud {
Azure,
#[serde(rename = "AWS")]
Aws,
#[serde(rename = "GCP")]
Gcp,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for StandardSupportedCloud {
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 StandardSupportedCloud {
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 StandardSupportedCloud {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Azure => serializer.serialize_unit_variant("StandardSupportedCloud", 0u32, "Azure"),
Self::Aws => serializer.serialize_unit_variant("StandardSupportedCloud", 1u32, "AWS"),
Self::Gcp => serializer.serialize_unit_variant("StandardSupportedCloud", 2u32, "GCP"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[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()),
}
}
}
}