#![doc = "generated by AutoRust"]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Action {
#[serde(rename = "odata.type")]
pub odata_type: String,
}
impl Action {
pub fn new(odata_type: String) -> Self {
Self { odata_type }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActionGroup {
#[serde(rename = "groupShortName")]
pub group_short_name: String,
pub enabled: bool,
#[serde(rename = "emailReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub email_receivers: Vec<EmailReceiver>,
#[serde(rename = "smsReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub sms_receivers: Vec<SmsReceiver>,
#[serde(rename = "webhookReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub webhook_receivers: Vec<WebhookReceiver>,
#[serde(rename = "itsmReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub itsm_receivers: Vec<ItsmReceiver>,
#[serde(rename = "azureAppPushReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub azure_app_push_receivers: Vec<AzureAppPushReceiver>,
#[serde(rename = "automationRunbookReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub automation_runbook_receivers: Vec<AutomationRunbookReceiver>,
#[serde(rename = "voiceReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub voice_receivers: Vec<VoiceReceiver>,
#[serde(rename = "logicAppReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub logic_app_receivers: Vec<LogicAppReceiver>,
#[serde(rename = "azureFunctionReceivers", default, skip_serializing_if = "Vec::is_empty")]
pub azure_function_receivers: Vec<AzureFunctionReceiver>,
}
impl ActionGroup {
pub fn new(group_short_name: String, enabled: bool) -> Self {
Self {
group_short_name,
enabled,
email_receivers: Vec::new(),
sms_receivers: Vec::new(),
webhook_receivers: Vec::new(),
itsm_receivers: Vec::new(),
azure_app_push_receivers: Vec::new(),
automation_runbook_receivers: Vec::new(),
voice_receivers: Vec::new(),
logic_app_receivers: Vec::new(),
azure_function_receivers: Vec::new(),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ActionGroupList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<ActionGroupResource>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl ActionGroupList {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ActionGroupPatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
impl ActionGroupPatch {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ActionGroupPatchBody {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ActionGroupPatch>,
}
impl ActionGroupPatchBody {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActionGroupResource {
#[serde(flatten)]
pub resource: Resource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ActionGroup>,
}
impl ActionGroupResource {
pub fn new(resource: Resource) -> Self {
Self {
resource,
properties: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActivityLogAlert {
pub scopes: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
pub condition: ActivityLogAlertAllOfCondition,
pub actions: ActivityLogAlertActionList,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
impl ActivityLogAlert {
pub fn new(scopes: Vec<String>, condition: ActivityLogAlertAllOfCondition, actions: ActivityLogAlertActionList) -> Self {
Self {
scopes,
enabled: None,
condition,
actions,
description: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActivityLogAlertActionGroup {
#[serde(rename = "actionGroupId")]
pub action_group_id: String,
#[serde(rename = "webhookProperties", default, skip_serializing_if = "Option::is_none")]
pub webhook_properties: Option<serde_json::Value>,
}
impl ActivityLogAlertActionGroup {
pub fn new(action_group_id: String) -> Self {
Self {
action_group_id,
webhook_properties: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ActivityLogAlertActionList {
#[serde(rename = "actionGroups", default, skip_serializing_if = "Vec::is_empty")]
pub action_groups: Vec<ActivityLogAlertActionGroup>,
}
impl ActivityLogAlertActionList {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActivityLogAlertAllOfCondition {
#[serde(rename = "allOf")]
pub all_of: Vec<ActivityLogAlertLeafCondition>,
}
impl ActivityLogAlertAllOfCondition {
pub fn new(all_of: Vec<ActivityLogAlertLeafCondition>) -> Self {
Self { all_of }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActivityLogAlertLeafCondition {
pub field: String,
pub equals: String,
}
impl ActivityLogAlertLeafCondition {
pub fn new(field: String, equals: String) -> Self {
Self { field, equals }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ActivityLogAlertList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<ActivityLogAlertResource>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl ActivityLogAlertList {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ActivityLogAlertPatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
impl ActivityLogAlertPatch {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ActivityLogAlertPatchBody {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ActivityLogAlertPatch>,
}
impl ActivityLogAlertPatchBody {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActivityLogAlertResource {
#[serde(flatten)]
pub resource: Resource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ActivityLogAlert>,
}
impl ActivityLogAlertResource {
pub fn new(resource: Resource) -> Self {
Self {
resource,
properties: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum AggregationType {
None,
Average,
Count,
Minimum,
Maximum,
Total,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRule {
pub name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<String>,
#[serde(rename = "isEnabled")]
pub is_enabled: bool,
pub condition: RuleCondition,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub action: Option<RuleAction>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub actions: Vec<RuleAction>,
#[serde(rename = "lastUpdatedTime", default, skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<String>,
}
impl AlertRule {
pub fn new(name: String, is_enabled: bool, condition: RuleCondition) -> Self {
Self {
name,
description: None,
provisioning_state: None,
is_enabled,
condition,
action: None,
actions: Vec::new(),
last_updated_time: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRuleResource {
#[serde(flatten)]
pub resource: Resource,
pub properties: AlertRule,
}
impl AlertRuleResource {
pub fn new(resource: Resource, properties: AlertRule) -> Self {
Self { resource, properties }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AlertRuleResourceCollection {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<AlertRuleResource>,
}
impl AlertRuleResourceCollection {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AlertRuleResourcePatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AlertRule>,
}
impl AlertRuleResourcePatch {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum AlertSeverity {
#[serde(rename = "0")]
N0,
#[serde(rename = "1")]
N1,
#[serde(rename = "2")]
N2,
#[serde(rename = "3")]
N3,
#[serde(rename = "4")]
N4,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertingAction {
#[serde(flatten)]
pub action: Action,
pub severity: AlertSeverity,
#[serde(rename = "aznsAction", default, skip_serializing_if = "Option::is_none")]
pub azns_action: Option<AzNsActionGroup>,
#[serde(rename = "throttlingInMin", default, skip_serializing_if = "Option::is_none")]
pub throttling_in_min: Option<i32>,
pub trigger: TriggerCondition,
}
impl AlertingAction {
pub fn new(action: Action, severity: AlertSeverity, trigger: TriggerCondition) -> Self {
Self {
action,
severity,
azns_action: None,
throttling_in_min: None,
trigger,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AutomationRunbookReceiver {
#[serde(rename = "automationAccountId")]
pub automation_account_id: String,
#[serde(rename = "runbookName")]
pub runbook_name: String,
#[serde(rename = "webhookResourceId")]
pub webhook_resource_id: String,
#[serde(rename = "isGlobalRunbook")]
pub is_global_runbook: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
pub service_uri: Option<String>,
}
impl AutomationRunbookReceiver {
pub fn new(automation_account_id: String, runbook_name: String, webhook_resource_id: String, is_global_runbook: bool) -> Self {
Self {
automation_account_id,
runbook_name,
webhook_resource_id,
is_global_runbook,
name: None,
service_uri: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AutoscaleNotification {
pub operation: autoscale_notification::Operation,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub email: Option<EmailNotification>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub webhooks: Vec<WebhookNotification>,
}
impl AutoscaleNotification {
pub fn new(operation: autoscale_notification::Operation) -> Self {
Self {
operation,
email: None,
webhooks: Vec::new(),
}
}
}
pub mod autoscale_notification {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Operation {
Scale,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AutoscaleProfile {
pub name: String,
pub capacity: ScaleCapacity,
pub rules: Vec<ScaleRule>,
#[serde(rename = "fixedDate", default, skip_serializing_if = "Option::is_none")]
pub fixed_date: Option<TimeWindow>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub recurrence: Option<Recurrence>,
}
impl AutoscaleProfile {
pub fn new(name: String, capacity: ScaleCapacity, rules: Vec<ScaleRule>) -> Self {
Self {
name,
capacity,
rules,
fixed_date: None,
recurrence: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AutoscaleSetting {
pub profiles: Vec<AutoscaleProfile>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub notifications: Vec<AutoscaleNotification>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "targetResourceUri", default, skip_serializing_if = "Option::is_none")]
pub target_resource_uri: Option<String>,
#[serde(rename = "targetResourceLocation", default, skip_serializing_if = "Option::is_none")]
pub target_resource_location: Option<String>,
}
impl AutoscaleSetting {
pub fn new(profiles: Vec<AutoscaleProfile>) -> Self {
Self {
profiles,
notifications: Vec::new(),
enabled: None,
name: None,
target_resource_uri: None,
target_resource_location: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AutoscaleSettingResource {
#[serde(flatten)]
pub resource: Resource,
pub properties: AutoscaleSetting,
}
impl AutoscaleSettingResource {
pub fn new(resource: Resource, properties: AutoscaleSetting) -> Self {
Self { resource, properties }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AutoscaleSettingResourceCollection {
pub value: Vec<AutoscaleSettingResource>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl AutoscaleSettingResourceCollection {
pub fn new(value: Vec<AutoscaleSettingResource>) -> Self {
Self { value, next_link: None }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AutoscaleSettingResourcePatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AutoscaleSetting>,
}
impl AutoscaleSettingResourcePatch {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AzNsActionGroup {
#[serde(rename = "actionGroup", default, skip_serializing_if = "Vec::is_empty")]
pub action_group: Vec<String>,
#[serde(rename = "emailSubject", default, skip_serializing_if = "Option::is_none")]
pub email_subject: Option<String>,
#[serde(rename = "customWebhookPayload", default, skip_serializing_if = "Option::is_none")]
pub custom_webhook_payload: Option<String>,
}
impl AzNsActionGroup {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AzureAppPushReceiver {
pub name: String,
#[serde(rename = "emailAddress")]
pub email_address: String,
}
impl AzureAppPushReceiver {
pub fn new(name: String, email_address: String) -> Self {
Self { name, email_address }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AzureFunctionReceiver {
pub name: String,
#[serde(rename = "functionAppResourceId")]
pub function_app_resource_id: String,
#[serde(rename = "functionName")]
pub function_name: String,
#[serde(rename = "httpTriggerUrl")]
pub http_trigger_url: String,
}
impl AzureFunctionReceiver {
pub fn new(name: String, function_app_resource_id: String, function_name: String, http_trigger_url: String) -> Self {
Self {
name,
function_app_resource_id,
function_name,
http_trigger_url,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Baseline {
pub sensitivity: baseline::Sensitivity,
#[serde(rename = "lowThresholds")]
pub low_thresholds: Vec<f64>,
#[serde(rename = "highThresholds")]
pub high_thresholds: Vec<f64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub timestamps: Vec<String>,
}
impl Baseline {
pub fn new(sensitivity: baseline::Sensitivity, low_thresholds: Vec<f64>, high_thresholds: Vec<f64>) -> Self {
Self {
sensitivity,
low_thresholds,
high_thresholds,
timestamps: Vec::new(),
}
}
}
pub mod baseline {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Sensitivity {
Low,
Medium,
High,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct BaselineMetadataValue {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<LocalizableString>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
impl BaselineMetadataValue {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct BaselineProperties {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timespan: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub interval: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub aggregation: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub timestamps: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub baseline: Vec<Baseline>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub metadata: Vec<BaselineMetadataValue>,
}
impl BaselineProperties {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct BaselineResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<LocalizableString>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<BaselineProperties>,
}
impl BaselineResponse {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CalculateBaselineResponse {
#[serde(rename = "type")]
pub type_: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub timestamps: Vec<String>,
pub baseline: Vec<Baseline>,
}
impl CalculateBaselineResponse {
pub fn new(type_: String, baseline: Vec<Baseline>) -> Self {
Self {
type_,
timestamps: Vec::new(),
baseline,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ConditionOperator {
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ConditionalOperator {
GreaterThanOrEqual,
LessThanOrEqual,
GreaterThan,
LessThan,
Equal,
}
impl Default for ConditionalOperator {
fn default() -> Self {
Self::GreaterThanOrEqual
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Criteria {
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub dimensions: Vec<Dimension>,
}
impl Criteria {
pub fn new(metric_name: String) -> Self {
Self {
metric_name,
dimensions: Vec::new(),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DiagnosticSettings {
#[serde(rename = "storageAccountId", default, skip_serializing_if = "Option::is_none")]
pub storage_account_id: Option<String>,
#[serde(rename = "serviceBusRuleId", default, skip_serializing_if = "Option::is_none")]
pub service_bus_rule_id: Option<String>,
#[serde(rename = "eventHubAuthorizationRuleId", default, skip_serializing_if = "Option::is_none")]
pub event_hub_authorization_rule_id: Option<String>,
#[serde(rename = "eventHubName", default, skip_serializing_if = "Option::is_none")]
pub event_hub_name: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub metrics: Vec<MetricSettings>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub logs: Vec<LogSettings>,
#[serde(rename = "workspaceId", default, skip_serializing_if = "Option::is_none")]
pub workspace_id: Option<String>,
#[serde(rename = "logAnalyticsDestinationType", default, skip_serializing_if = "Option::is_none")]
pub log_analytics_destination_type: Option<String>,
}
impl DiagnosticSettings {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DiagnosticSettingsCategory {
#[serde(rename = "categoryType", default, skip_serializing_if = "Option::is_none")]
pub category_type: Option<diagnostic_settings_category::CategoryType>,
}
impl DiagnosticSettingsCategory {
pub fn new() -> Self {
Self::default()
}
}
pub mod diagnostic_settings_category {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum CategoryType {
Metrics,
Logs,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DiagnosticSettingsCategoryResource {
#[serde(flatten)]
pub proxy_only_resource: ProxyOnlyResource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<DiagnosticSettingsCategory>,
}
impl DiagnosticSettingsCategoryResource {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DiagnosticSettingsCategoryResourceCollection {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<DiagnosticSettingsCategoryResource>,
}
impl DiagnosticSettingsCategoryResourceCollection {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DiagnosticSettingsResource {
#[serde(flatten)]
pub proxy_only_resource: ProxyOnlyResource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<DiagnosticSettings>,
}
impl DiagnosticSettingsResource {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DiagnosticSettingsResourceCollection {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<DiagnosticSettingsResource>,
}
impl DiagnosticSettingsResourceCollection {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Dimension {
pub name: String,
pub operator: dimension::Operator,
pub values: Vec<String>,
}
impl Dimension {
pub fn new(name: String, operator: dimension::Operator, values: Vec<String>) -> Self {
Self { name, operator, values }
}
}
pub mod dimension {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Operator {
Include,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DynamicMetricCriteria {
#[serde(flatten)]
pub multi_metric_criteria: MultiMetricCriteria,
pub operator: dynamic_metric_criteria::Operator,
#[serde(rename = "alertSensitivity")]
pub alert_sensitivity: dynamic_metric_criteria::AlertSensitivity,
#[serde(rename = "failingPeriods")]
pub failing_periods: DynamicThresholdFailingPeriods,
#[serde(rename = "ignoreDataBefore", default, skip_serializing_if = "Option::is_none")]
pub ignore_data_before: Option<String>,
}
impl DynamicMetricCriteria {
pub fn new(
multi_metric_criteria: MultiMetricCriteria,
operator: dynamic_metric_criteria::Operator,
alert_sensitivity: dynamic_metric_criteria::AlertSensitivity,
failing_periods: DynamicThresholdFailingPeriods,
) -> Self {
Self {
multi_metric_criteria,
operator,
alert_sensitivity,
failing_periods,
ignore_data_before: None,
}
}
}
pub mod dynamic_metric_criteria {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Operator {
GreaterThan,
LessThan,
GreaterOrLessThan,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum AlertSensitivity {
Low,
Medium,
High,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DynamicThresholdFailingPeriods {
#[serde(rename = "numberOfEvaluationPeriods")]
pub number_of_evaluation_periods: f64,
#[serde(rename = "minFailingPeriodsToAlert")]
pub min_failing_periods_to_alert: f64,
}
impl DynamicThresholdFailingPeriods {
pub fn new(number_of_evaluation_periods: f64, min_failing_periods_to_alert: f64) -> Self {
Self {
number_of_evaluation_periods,
min_failing_periods_to_alert,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct EmailNotification {
#[serde(rename = "sendToSubscriptionAdministrator", default, skip_serializing_if = "Option::is_none")]
pub send_to_subscription_administrator: Option<bool>,
#[serde(rename = "sendToSubscriptionCoAdministrators", default, skip_serializing_if = "Option::is_none")]
pub send_to_subscription_co_administrators: Option<bool>,
#[serde(rename = "customEmails", default, skip_serializing_if = "Vec::is_empty")]
pub custom_emails: Vec<String>,
}
impl EmailNotification {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EmailReceiver {
pub name: String,
#[serde(rename = "emailAddress")]
pub email_address: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<ReceiverStatus>,
}
impl EmailReceiver {
pub fn new(name: String, email_address: String) -> Self {
Self {
name,
email_address,
status: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EnableRequest {
#[serde(rename = "receiverName")]
pub receiver_name: String,
}
impl EnableRequest {
pub fn new(receiver_name: String) -> Self {
Self { receiver_name }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ErrorContract {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorResponse>,
}
impl ErrorContract {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ErrorResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
impl ErrorResponse {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EventCategoryCollection {
pub value: Vec<LocalizableString>,
}
impl EventCategoryCollection {
pub fn new(value: Vec<LocalizableString>) -> Self {
Self { value }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct EventData {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub authorization: Option<SenderAuthorization>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub claims: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub caller: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "eventDataId", default, skip_serializing_if = "Option::is_none")]
pub event_data_id: Option<String>,
#[serde(rename = "correlationId", default, skip_serializing_if = "Option::is_none")]
pub correlation_id: Option<String>,
#[serde(rename = "eventName", default, skip_serializing_if = "Option::is_none")]
pub event_name: Option<LocalizableString>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub category: Option<LocalizableString>,
#[serde(rename = "httpRequest", default, skip_serializing_if = "Option::is_none")]
pub http_request: Option<HttpRequestInfo>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub level: Option<event_data::Level>,
#[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
#[serde(rename = "resourceProviderName", default, skip_serializing_if = "Option::is_none")]
pub resource_provider_name: Option<LocalizableString>,
#[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "resourceType", default, skip_serializing_if = "Option::is_none")]
pub resource_type: Option<LocalizableString>,
#[serde(rename = "operationId", default, skip_serializing_if = "Option::is_none")]
pub operation_id: Option<String>,
#[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
pub operation_name: Option<LocalizableString>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<LocalizableString>,
#[serde(rename = "subStatus", default, skip_serializing_if = "Option::is_none")]
pub sub_status: Option<LocalizableString>,
#[serde(rename = "eventTimestamp", default, skip_serializing_if = "Option::is_none")]
pub event_timestamp: Option<String>,
#[serde(rename = "submissionTimestamp", default, skip_serializing_if = "Option::is_none")]
pub submission_timestamp: Option<String>,
#[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
pub subscription_id: Option<String>,
#[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
pub tenant_id: Option<String>,
}
impl EventData {
pub fn new() -> Self {
Self::default()
}
}
pub mod event_data {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Level {
Critical,
Error,
Warning,
Informational,
Verbose,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EventDataCollection {
pub value: Vec<EventData>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl EventDataCollection {
pub fn new(value: Vec<EventData>) -> Self {
Self { value, next_link: None }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct HttpRequestInfo {
#[serde(rename = "clientRequestId", default, skip_serializing_if = "Option::is_none")]
pub client_request_id: Option<String>,
#[serde(rename = "clientIpAddress", default, skip_serializing_if = "Option::is_none")]
pub client_ip_address: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub method: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub uri: Option<String>,
}
impl HttpRequestInfo {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Incident {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ruleName", default, skip_serializing_if = "Option::is_none")]
pub rule_name: Option<String>,
#[serde(rename = "isActive", default, skip_serializing_if = "Option::is_none")]
pub is_active: Option<bool>,
#[serde(rename = "activatedTime", default, skip_serializing_if = "Option::is_none")]
pub activated_time: Option<String>,
#[serde(rename = "resolvedTime", default, skip_serializing_if = "Option::is_none")]
pub resolved_time: Option<String>,
}
impl Incident {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct IncidentListResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<Incident>,
}
impl IncidentListResult {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ItsmReceiver {
pub name: String,
#[serde(rename = "workspaceId")]
pub workspace_id: String,
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "ticketConfiguration")]
pub ticket_configuration: String,
pub region: String,
}
impl ItsmReceiver {
pub fn new(name: String, workspace_id: String, connection_id: String, ticket_configuration: String, region: String) -> Self {
Self {
name,
workspace_id,
connection_id,
ticket_configuration,
region,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LocalizableString {
pub value: String,
#[serde(rename = "localizedValue", default, skip_serializing_if = "Option::is_none")]
pub localized_value: Option<String>,
}
impl LocalizableString {
pub fn new(value: String) -> Self {
Self {
value,
localized_value: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LocationThresholdRuleCondition {
#[serde(flatten)]
pub rule_condition: RuleCondition,
#[serde(rename = "windowSize", default, skip_serializing_if = "Option::is_none")]
pub window_size: Option<String>,
#[serde(rename = "failedLocationCount")]
pub failed_location_count: i32,
}
impl LocationThresholdRuleCondition {
pub fn new(rule_condition: RuleCondition, failed_location_count: i32) -> Self {
Self {
rule_condition,
window_size: None,
failed_location_count,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct LogMetricTrigger {
#[serde(rename = "thresholdOperator", default, skip_serializing_if = "Option::is_none")]
pub threshold_operator: Option<ConditionalOperator>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub threshold: Option<f64>,
#[serde(rename = "metricTriggerType", default, skip_serializing_if = "Option::is_none")]
pub metric_trigger_type: Option<MetricTriggerType>,
#[serde(rename = "metricColumn", default, skip_serializing_if = "Option::is_none")]
pub metric_column: Option<String>,
}
impl LogMetricTrigger {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LogProfileCollection {
pub value: Vec<LogProfileResource>,
}
impl LogProfileCollection {
pub fn new(value: Vec<LogProfileResource>) -> Self {
Self { value }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LogProfileProperties {
#[serde(rename = "storageAccountId", default, skip_serializing_if = "Option::is_none")]
pub storage_account_id: Option<String>,
#[serde(rename = "serviceBusRuleId", default, skip_serializing_if = "Option::is_none")]
pub service_bus_rule_id: Option<String>,
pub locations: Vec<String>,
pub categories: Vec<String>,
#[serde(rename = "retentionPolicy")]
pub retention_policy: RetentionPolicy,
}
impl LogProfileProperties {
pub fn new(locations: Vec<String>, categories: Vec<String>, retention_policy: RetentionPolicy) -> Self {
Self {
storage_account_id: None,
service_bus_rule_id: None,
locations,
categories,
retention_policy,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LogProfileResource {
#[serde(flatten)]
pub resource: Resource,
pub properties: LogProfileProperties,
}
impl LogProfileResource {
pub fn new(resource: Resource, properties: LogProfileProperties) -> Self {
Self { resource, properties }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct LogProfileResourcePatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<LogProfileProperties>,
}
impl LogProfileResourcePatch {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LogSearchRule {
#[serde(rename = "createdWithApiVersion", default, skip_serializing_if = "Option::is_none")]
pub created_with_api_version: Option<String>,
#[serde(rename = "isLegacyLogAnalyticsRule", default, skip_serializing_if = "Option::is_none")]
pub is_legacy_log_analytics_rule: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "autoMitigate", default, skip_serializing_if = "Option::is_none")]
pub auto_mitigate: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<log_search_rule::Enabled>,
#[serde(rename = "lastUpdatedTime", default, skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<String>,
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<log_search_rule::ProvisioningState>,
pub source: Source,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub schedule: Option<Schedule>,
pub action: Action,
}
impl LogSearchRule {
pub fn new(source: Source, action: Action) -> Self {
Self {
created_with_api_version: None,
is_legacy_log_analytics_rule: None,
description: None,
display_name: None,
auto_mitigate: None,
enabled: None,
last_updated_time: None,
provisioning_state: None,
source,
schedule: None,
action,
}
}
}
pub mod log_search_rule {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Enabled {
#[serde(rename = "true")]
True,
#[serde(rename = "false")]
False,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ProvisioningState {
Succeeded,
Deploying,
Canceled,
Failed,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct LogSearchRulePatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<log_search_rule_patch::Enabled>,
}
impl LogSearchRulePatch {
pub fn new() -> Self {
Self::default()
}
}
pub mod log_search_rule_patch {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Enabled {
#[serde(rename = "true")]
True,
#[serde(rename = "false")]
False,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LogSearchRuleResource {
#[serde(flatten)]
pub resource: Resource,
pub properties: LogSearchRule,
}
impl LogSearchRuleResource {
pub fn new(resource: Resource, properties: LogSearchRule) -> Self {
Self { resource, properties }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct LogSearchRuleResourceCollection {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<LogSearchRuleResource>,
}
impl LogSearchRuleResourceCollection {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct LogSearchRuleResourcePatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<LogSearchRulePatch>,
}
impl LogSearchRuleResourcePatch {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LogSettings {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
pub enabled: bool,
#[serde(rename = "retentionPolicy", default, skip_serializing_if = "Option::is_none")]
pub retention_policy: Option<RetentionPolicy>,
}
impl LogSettings {
pub fn new(enabled: bool) -> Self {
Self {
category: None,
enabled,
retention_policy: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LogToMetricAction {
#[serde(flatten)]
pub action: Action,
pub criteria: Vec<Criteria>,
}
impl LogToMetricAction {
pub fn new(action: Action, criteria: Vec<Criteria>) -> Self {
Self { action, criteria }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LogicAppReceiver {
pub name: String,
#[serde(rename = "resourceId")]
pub resource_id: String,
#[serde(rename = "callbackUrl")]
pub callback_url: String,
}
impl LogicAppReceiver {
pub fn new(name: String, resource_id: String, callback_url: String) -> Self {
Self {
name,
resource_id,
callback_url,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ManagementEventAggregationCondition {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub operator: Option<ConditionOperator>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub threshold: Option<f64>,
#[serde(rename = "windowSize", default, skip_serializing_if = "Option::is_none")]
pub window_size: Option<String>,
}
impl ManagementEventAggregationCondition {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ManagementEventRuleCondition {
#[serde(flatten)]
pub rule_condition: RuleCondition,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub aggregation: Option<ManagementEventAggregationCondition>,
}
impl ManagementEventRuleCondition {
pub fn new(rule_condition: RuleCondition) -> Self {
Self {
rule_condition,
aggregation: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetadataValue {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<LocalizableString>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
impl MetadataValue {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Metric {
pub id: String,
#[serde(rename = "type")]
pub type_: String,
pub name: LocalizableString,
#[serde(rename = "displayDescription", default, skip_serializing_if = "Option::is_none")]
pub display_description: Option<String>,
#[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "errorMessage", default, skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
pub unit: Unit,
pub timeseries: Vec<TimeSeriesElement>,
}
impl Metric {
pub fn new(id: String, type_: String, name: LocalizableString, unit: Unit, timeseries: Vec<TimeSeriesElement>) -> Self {
Self {
id,
type_,
name,
display_description: None,
error_code: None,
error_message: None,
unit,
timeseries,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricAlertAction {
#[serde(rename = "actionGroupId", default, skip_serializing_if = "Option::is_none")]
pub action_group_id: Option<String>,
#[serde(rename = "webHookProperties", default, skip_serializing_if = "Option::is_none")]
pub web_hook_properties: Option<serde_json::Value>,
}
impl MetricAlertAction {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricAlertCriteria {
#[serde(rename = "odata.type")]
pub odata_type: metric_alert_criteria::OdataType,
}
impl MetricAlertCriteria {
pub fn new(odata_type: metric_alert_criteria::OdataType) -> Self {
Self { odata_type }
}
}
pub mod metric_alert_criteria {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum OdataType {
#[serde(rename = "Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria")]
MicrosoftAzureMonitorSingleResourceMultipleMetricCriteria,
#[serde(rename = "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria")]
MicrosoftAzureMonitorMultipleResourceMultipleMetricCriteria,
#[serde(rename = "Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria")]
MicrosoftAzureMonitorWebtestLocationAvailabilityCriteria,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricAlertMultipleResourceMultipleMetricCriteria {
#[serde(flatten)]
pub metric_alert_criteria: MetricAlertCriteria,
#[serde(rename = "allOf", default, skip_serializing_if = "Vec::is_empty")]
pub all_of: Vec<MultiMetricCriteria>,
}
impl MetricAlertMultipleResourceMultipleMetricCriteria {
pub fn new(metric_alert_criteria: MetricAlertCriteria) -> Self {
Self {
metric_alert_criteria,
all_of: Vec::new(),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricAlertProperties {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
pub severity: i32,
pub enabled: bool,
pub scopes: Vec<String>,
#[serde(rename = "evaluationFrequency")]
pub evaluation_frequency: String,
#[serde(rename = "windowSize")]
pub window_size: String,
#[serde(rename = "targetResourceType", default, skip_serializing_if = "Option::is_none")]
pub target_resource_type: Option<String>,
#[serde(rename = "targetResourceRegion", default, skip_serializing_if = "Option::is_none")]
pub target_resource_region: Option<String>,
pub criteria: MetricAlertCriteria,
#[serde(rename = "autoMitigate", default, skip_serializing_if = "Option::is_none")]
pub auto_mitigate: Option<bool>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub actions: Vec<MetricAlertAction>,
#[serde(rename = "lastUpdatedTime", default, skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<String>,
#[serde(rename = "isMigrated", default, skip_serializing_if = "Option::is_none")]
pub is_migrated: Option<bool>,
}
impl MetricAlertProperties {
pub fn new(
severity: i32,
enabled: bool,
scopes: Vec<String>,
evaluation_frequency: String,
window_size: String,
criteria: MetricAlertCriteria,
) -> Self {
Self {
description: None,
severity,
enabled,
scopes,
evaluation_frequency,
window_size,
target_resource_type: None,
target_resource_region: None,
criteria,
auto_mitigate: None,
actions: Vec::new(),
last_updated_time: None,
is_migrated: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricAlertPropertiesPatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub severity: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub scopes: Vec<String>,
#[serde(rename = "evaluationFrequency", default, skip_serializing_if = "Option::is_none")]
pub evaluation_frequency: Option<String>,
#[serde(rename = "windowSize", default, skip_serializing_if = "Option::is_none")]
pub window_size: Option<String>,
#[serde(rename = "targetResourceType", default, skip_serializing_if = "Option::is_none")]
pub target_resource_type: Option<String>,
#[serde(rename = "targetResourceRegion", default, skip_serializing_if = "Option::is_none")]
pub target_resource_region: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub criteria: Option<MetricAlertCriteria>,
#[serde(rename = "autoMitigate", default, skip_serializing_if = "Option::is_none")]
pub auto_mitigate: Option<bool>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub actions: Vec<MetricAlertAction>,
#[serde(rename = "lastUpdatedTime", default, skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<String>,
#[serde(rename = "isMigrated", default, skip_serializing_if = "Option::is_none")]
pub is_migrated: Option<bool>,
}
impl MetricAlertPropertiesPatch {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricAlertResource {
#[serde(flatten)]
pub resource: Resource,
pub properties: MetricAlertProperties,
}
impl MetricAlertResource {
pub fn new(resource: Resource, properties: MetricAlertProperties) -> Self {
Self { resource, properties }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricAlertResourceCollection {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<MetricAlertResource>,
}
impl MetricAlertResourceCollection {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricAlertResourcePatch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<MetricAlertPropertiesPatch>,
}
impl MetricAlertResourcePatch {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricAlertSingleResourceMultipleMetricCriteria {
#[serde(flatten)]
pub metric_alert_criteria: MetricAlertCriteria,
#[serde(rename = "allOf", default, skip_serializing_if = "Vec::is_empty")]
pub all_of: Vec<MetricCriteria>,
}
impl MetricAlertSingleResourceMultipleMetricCriteria {
pub fn new(metric_alert_criteria: MetricAlertCriteria) -> Self {
Self {
metric_alert_criteria,
all_of: Vec::new(),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricAlertStatus {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<MetricAlertStatusProperties>,
}
impl MetricAlertStatus {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricAlertStatusCollection {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<MetricAlertStatus>,
}
impl MetricAlertStatusCollection {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricAlertStatusProperties {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dimensions: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timestamp: Option<String>,
}
impl MetricAlertStatusProperties {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricAvailability {
#[serde(rename = "timeGrain", default, skip_serializing_if = "Option::is_none")]
pub time_grain: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub retention: Option<String>,
}
impl MetricAvailability {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum MetricClass {
Availability,
Transactions,
Errors,
Latency,
Saturation,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricCriteria {
#[serde(flatten)]
pub multi_metric_criteria: MultiMetricCriteria,
pub operator: metric_criteria::Operator,
pub threshold: f64,
}
impl MetricCriteria {
pub fn new(multi_metric_criteria: MultiMetricCriteria, operator: metric_criteria::Operator, threshold: f64) -> Self {
Self {
multi_metric_criteria,
operator,
threshold,
}
}
}
pub mod metric_criteria {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Operator {
Equals,
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct MetricDefinition {
#[serde(rename = "isDimensionRequired", default, skip_serializing_if = "Option::is_none")]
pub is_dimension_required: Option<bool>,
#[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub namespace: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<LocalizableString>,
#[serde(rename = "displayDescription", default, skip_serializing_if = "Option::is_none")]
pub display_description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
#[serde(rename = "metricClass", default, skip_serializing_if = "Option::is_none")]
pub metric_class: Option<MetricClass>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unit: Option<Unit>,
#[serde(rename = "primaryAggregationType", default, skip_serializing_if = "Option::is_none")]
pub primary_aggregation_type: Option<AggregationType>,
#[serde(rename = "supportedAggregationTypes", default, skip_serializing_if = "Vec::is_empty")]
pub supported_aggregation_types: Vec<AggregationType>,
#[serde(rename = "metricAvailabilities", default, skip_serializing_if = "Vec::is_empty")]
pub metric_availabilities: Vec<MetricAvailability>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub dimensions: Vec<LocalizableString>,
}
impl MetricDefinition {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricDefinitionCollection {
pub value: Vec<MetricDefinition>,
}
impl MetricDefinitionCollection {
pub fn new(value: Vec<MetricDefinition>) -> Self {
Self { value }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricDimension {
pub name: String,
pub operator: String,
pub values: Vec<String>,
}
impl MetricDimension {
pub fn new(name: String, operator: String, values: Vec<String>) -> Self {
Self { name, operator, values }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricSettings {
#[serde(rename = "timeGrain", default, skip_serializing_if = "Option::is_none")]
pub time_grain: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub category: Option<String>,
pub enabled: bool,
#[serde(rename = "retentionPolicy", default, skip_serializing_if = "Option::is_none")]
pub retention_policy: Option<RetentionPolicy>,
}
impl MetricSettings {
pub fn new(enabled: bool) -> Self {
Self {
time_grain: None,
category: None,
enabled,
retention_policy: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricTrigger {
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(rename = "metricNamespace", default, skip_serializing_if = "Option::is_none")]
pub metric_namespace: Option<String>,
#[serde(rename = "metricResourceUri")]
pub metric_resource_uri: String,
#[serde(rename = "metricResourceLocation", default, skip_serializing_if = "Option::is_none")]
pub metric_resource_location: Option<String>,
#[serde(rename = "timeGrain")]
pub time_grain: String,
pub statistic: metric_trigger::Statistic,
#[serde(rename = "timeWindow")]
pub time_window: String,
#[serde(rename = "timeAggregation")]
pub time_aggregation: metric_trigger::TimeAggregation,
pub operator: metric_trigger::Operator,
pub threshold: f64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub dimensions: Vec<ScaleRuleMetricDimension>,
#[serde(rename = "dividePerInstance", default, skip_serializing_if = "Option::is_none")]
pub divide_per_instance: Option<bool>,
}
impl MetricTrigger {
pub fn new(
metric_name: String,
metric_resource_uri: String,
time_grain: String,
statistic: metric_trigger::Statistic,
time_window: String,
time_aggregation: metric_trigger::TimeAggregation,
operator: metric_trigger::Operator,
threshold: f64,
) -> Self {
Self {
metric_name,
metric_namespace: None,
metric_resource_uri,
metric_resource_location: None,
time_grain,
statistic,
time_window,
time_aggregation,
operator,
threshold,
dimensions: Vec::new(),
divide_per_instance: None,
}
}
}
pub mod metric_trigger {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Statistic {
Average,
Min,
Max,
Sum,
Count,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum TimeAggregation {
Average,
Minimum,
Maximum,
Total,
Count,
Last,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Operator {
Equals,
NotEquals,
GreaterThan,
GreaterThanOrEqual,
LessThan,
LessThanOrEqual,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum MetricTriggerType {
Consecutive,
Total,
}
impl Default for MetricTriggerType {
fn default() -> Self {
Self::Consecutive
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MetricValue {
#[serde(rename = "timeStamp")]
pub time_stamp: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub average: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub minimum: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub maximum: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub total: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub count: Option<f64>,
}
impl MetricValue {
pub fn new(time_stamp: String) -> Self {
Self {
time_stamp,
average: None,
minimum: None,
maximum: None,
total: None,
count: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MultiMetricCriteria {
#[serde(rename = "criterionType")]
pub criterion_type: multi_metric_criteria::CriterionType,
pub name: String,
#[serde(rename = "metricName")]
pub metric_name: String,
#[serde(rename = "metricNamespace", default, skip_serializing_if = "Option::is_none")]
pub metric_namespace: Option<String>,
#[serde(rename = "timeAggregation")]
pub time_aggregation: multi_metric_criteria::TimeAggregation,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub dimensions: Vec<MetricDimension>,
#[serde(rename = "skipMetricValidation", default, skip_serializing_if = "Option::is_none")]
pub skip_metric_validation: Option<bool>,
}
impl MultiMetricCriteria {
pub fn new(
criterion_type: multi_metric_criteria::CriterionType,
name: String,
metric_name: String,
time_aggregation: multi_metric_criteria::TimeAggregation,
) -> Self {
Self {
criterion_type,
name,
metric_name,
metric_namespace: None,
time_aggregation,
dimensions: Vec::new(),
skip_metric_validation: None,
}
}
}
pub mod multi_metric_criteria {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum CriterionType {
StaticThresholdCriterion,
DynamicThresholdCriterion,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum TimeAggregation {
Average,
Count,
Minimum,
Maximum,
Total,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Operation {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub display: Option<operation::Display>,
}
impl Operation {
pub fn new() -> Self {
Self::default()
}
}
pub mod operation {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Display {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub operation: Option<String>,
}
impl Display {
pub fn new() -> Self {
Self::default()
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationListResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<Operation>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl OperationListResult {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ProxyOnlyResource {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
impl ProxyOnlyResource {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum QueryType {
ResultCount,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ReceiverStatus {
NotSpecified,
Enabled,
Disabled,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Recurrence {
pub frequency: recurrence::Frequency,
pub schedule: RecurrentSchedule,
}
impl Recurrence {
pub fn new(frequency: recurrence::Frequency, schedule: RecurrentSchedule) -> Self {
Self { frequency, schedule }
}
}
pub mod recurrence {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Frequency {
None,
Second,
Minute,
Hour,
Day,
Week,
Month,
Year,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RecurrentSchedule {
#[serde(rename = "timeZone")]
pub time_zone: String,
pub days: Vec<String>,
pub hours: Vec<i32>,
pub minutes: Vec<i32>,
}
impl RecurrentSchedule {
pub fn new(time_zone: String, days: Vec<String>, hours: Vec<i32>, minutes: Vec<i32>) -> Self {
Self {
time_zone,
days,
hours,
minutes,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Resource {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
pub location: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
}
impl Resource {
pub fn new(location: String) -> Self {
Self {
id: None,
name: None,
type_: None,
location,
tags: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Response {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cost: Option<f64>,
pub timespan: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub interval: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub namespace: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resourceregion: Option<String>,
pub value: Vec<Metric>,
}
impl Response {
pub fn new(timespan: String, value: Vec<Metric>) -> Self {
Self {
cost: None,
timespan,
interval: None,
namespace: None,
resourceregion: None,
value,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RetentionPolicy {
pub enabled: bool,
pub days: i32,
}
impl RetentionPolicy {
pub fn new(enabled: bool, days: i32) -> Self {
Self { enabled, days }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RuleAction {
#[serde(rename = "odata.type")]
pub odata_type: String,
}
impl RuleAction {
pub fn new(odata_type: String) -> Self {
Self { odata_type }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RuleCondition {
#[serde(rename = "odata.type")]
pub odata_type: String,
#[serde(rename = "dataSource", default, skip_serializing_if = "Option::is_none")]
pub data_source: Option<RuleDataSource>,
}
impl RuleCondition {
pub fn new(odata_type: String) -> Self {
Self {
odata_type,
data_source: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RuleDataSource {
#[serde(rename = "odata.type")]
pub odata_type: String,
#[serde(rename = "resourceUri", default, skip_serializing_if = "Option::is_none")]
pub resource_uri: Option<String>,
#[serde(rename = "legacyResourceId", default, skip_serializing_if = "Option::is_none")]
pub legacy_resource_id: Option<String>,
#[serde(rename = "resourceLocation", default, skip_serializing_if = "Option::is_none")]
pub resource_location: Option<String>,
#[serde(rename = "metricNamespace", default, skip_serializing_if = "Option::is_none")]
pub metric_namespace: Option<String>,
}
impl RuleDataSource {
pub fn new(odata_type: String) -> Self {
Self {
odata_type,
resource_uri: None,
legacy_resource_id: None,
resource_location: None,
metric_namespace: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RuleEmailAction {
#[serde(flatten)]
pub rule_action: RuleAction,
#[serde(rename = "sendToServiceOwners", default, skip_serializing_if = "Option::is_none")]
pub send_to_service_owners: Option<bool>,
#[serde(rename = "customEmails", default, skip_serializing_if = "Vec::is_empty")]
pub custom_emails: Vec<String>,
}
impl RuleEmailAction {
pub fn new(rule_action: RuleAction) -> Self {
Self {
rule_action,
send_to_service_owners: None,
custom_emails: Vec::new(),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct RuleManagementEventClaimsDataSource {
#[serde(rename = "emailAddress", default, skip_serializing_if = "Option::is_none")]
pub email_address: Option<String>,
}
impl RuleManagementEventClaimsDataSource {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RuleManagementEventDataSource {
#[serde(flatten)]
pub rule_data_source: RuleDataSource,
#[serde(rename = "eventName", default, skip_serializing_if = "Option::is_none")]
pub event_name: Option<String>,
#[serde(rename = "eventSource", default, skip_serializing_if = "Option::is_none")]
pub event_source: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub level: Option<String>,
#[serde(rename = "operationName", default, skip_serializing_if = "Option::is_none")]
pub operation_name: Option<String>,
#[serde(rename = "resourceGroupName", default, skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
#[serde(rename = "resourceProviderName", default, skip_serializing_if = "Option::is_none")]
pub resource_provider_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "subStatus", default, skip_serializing_if = "Option::is_none")]
pub sub_status: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub claims: Option<RuleManagementEventClaimsDataSource>,
}
impl RuleManagementEventDataSource {
pub fn new(rule_data_source: RuleDataSource) -> Self {
Self {
rule_data_source,
event_name: None,
event_source: None,
level: None,
operation_name: None,
resource_group_name: None,
resource_provider_name: None,
status: None,
sub_status: None,
claims: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RuleMetricDataSource {
#[serde(flatten)]
pub rule_data_source: RuleDataSource,
#[serde(rename = "metricName", default, skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
}
impl RuleMetricDataSource {
pub fn new(rule_data_source: RuleDataSource) -> Self {
Self {
rule_data_source,
metric_name: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RuleWebhookAction {
#[serde(flatten)]
pub rule_action: RuleAction,
#[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
pub service_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<serde_json::Value>,
}
impl RuleWebhookAction {
pub fn new(rule_action: RuleAction) -> Self {
Self {
rule_action,
service_uri: None,
properties: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ScaleAction {
pub direction: scale_action::Direction,
#[serde(rename = "type")]
pub type_: scale_action::Type,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
pub cooldown: String,
}
impl ScaleAction {
pub fn new(direction: scale_action::Direction, type_: scale_action::Type, cooldown: String) -> Self {
Self {
direction,
type_,
value: None,
cooldown,
}
}
}
pub mod scale_action {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Direction {
None,
Increase,
Decrease,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Type {
ChangeCount,
PercentChangeCount,
ExactCount,
ServiceAllowedNextValue,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ScaleCapacity {
pub minimum: String,
pub maximum: String,
pub default: String,
}
impl ScaleCapacity {
pub fn new(minimum: String, maximum: String, default: String) -> Self {
Self { minimum, maximum, default }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ScaleRule {
#[serde(rename = "metricTrigger")]
pub metric_trigger: MetricTrigger,
#[serde(rename = "scaleAction")]
pub scale_action: ScaleAction,
}
impl ScaleRule {
pub fn new(metric_trigger: MetricTrigger, scale_action: ScaleAction) -> Self {
Self {
metric_trigger,
scale_action,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ScaleRuleMetricDimension {
#[serde(rename = "DimensionName")]
pub dimension_name: String,
#[serde(rename = "Operator")]
pub operator: scale_rule_metric_dimension::Operator,
#[serde(rename = "Values")]
pub values: Vec<String>,
}
impl ScaleRuleMetricDimension {
pub fn new(dimension_name: String, operator: scale_rule_metric_dimension::Operator, values: Vec<String>) -> Self {
Self {
dimension_name,
operator,
values,
}
}
}
pub mod scale_rule_metric_dimension {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Operator {
Equals,
NotEquals,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Schedule {
#[serde(rename = "frequencyInMinutes")]
pub frequency_in_minutes: i32,
#[serde(rename = "timeWindowInMinutes")]
pub time_window_in_minutes: i32,
}
impl Schedule {
pub fn new(frequency_in_minutes: i32, time_window_in_minutes: i32) -> Self {
Self {
frequency_in_minutes,
time_window_in_minutes,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SenderAuthorization {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
}
impl SenderAuthorization {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SmsReceiver {
pub name: String,
#[serde(rename = "countryCode")]
pub country_code: String,
#[serde(rename = "phoneNumber")]
pub phone_number: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<ReceiverStatus>,
}
impl SmsReceiver {
pub fn new(name: String, country_code: String, phone_number: String) -> Self {
Self {
name,
country_code,
phone_number,
status: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Source {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub query: Option<String>,
#[serde(rename = "authorizedResources", default, skip_serializing_if = "Vec::is_empty")]
pub authorized_resources: Vec<String>,
#[serde(rename = "dataSourceId")]
pub data_source_id: String,
#[serde(rename = "queryType", default, skip_serializing_if = "Option::is_none")]
pub query_type: Option<QueryType>,
}
impl Source {
pub fn new(data_source_id: String) -> Self {
Self {
query: None,
authorized_resources: Vec::new(),
data_source_id,
query_type: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ThresholdRuleCondition {
#[serde(flatten)]
pub rule_condition: RuleCondition,
pub operator: ConditionOperator,
pub threshold: f64,
#[serde(rename = "windowSize", default, skip_serializing_if = "Option::is_none")]
pub window_size: Option<String>,
#[serde(rename = "timeAggregation", default, skip_serializing_if = "Option::is_none")]
pub time_aggregation: Option<TimeAggregationOperator>,
}
impl ThresholdRuleCondition {
pub fn new(rule_condition: RuleCondition, operator: ConditionOperator, threshold: f64) -> Self {
Self {
rule_condition,
operator,
threshold,
window_size: None,
time_aggregation: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum TimeAggregationOperator {
Average,
Minimum,
Maximum,
Total,
Last,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TimeSeriesElement {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub metadatavalues: Vec<MetadataValue>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub data: Vec<MetricValue>,
}
impl TimeSeriesElement {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TimeSeriesInformation {
pub sensitivities: Vec<String>,
pub values: Vec<f64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub timestamps: Vec<String>,
}
impl TimeSeriesInformation {
pub fn new(sensitivities: Vec<String>, values: Vec<f64>) -> Self {
Self {
sensitivities,
values,
timestamps: Vec::new(),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TimeWindow {
#[serde(rename = "timeZone", default, skip_serializing_if = "Option::is_none")]
pub time_zone: Option<String>,
pub start: String,
pub end: String,
}
impl TimeWindow {
pub fn new(start: String, end: String) -> Self {
Self {
time_zone: None,
start,
end,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TriggerCondition {
#[serde(rename = "thresholdOperator")]
pub threshold_operator: ConditionalOperator,
pub threshold: f64,
#[serde(rename = "metricTrigger", default, skip_serializing_if = "Option::is_none")]
pub metric_trigger: Option<LogMetricTrigger>,
}
impl TriggerCondition {
pub fn new(threshold_operator: ConditionalOperator, threshold: f64) -> Self {
Self {
threshold_operator,
threshold,
metric_trigger: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Unit {
Count,
Bytes,
Seconds,
CountPerSecond,
BytesPerSecond,
Percent,
MilliSeconds,
ByteSeconds,
Unspecified,
Cores,
MilliCores,
NanoCores,
BitsPerSecond,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct VoiceReceiver {
pub name: String,
#[serde(rename = "countryCode")]
pub country_code: String,
#[serde(rename = "phoneNumber")]
pub phone_number: String,
}
impl VoiceReceiver {
pub fn new(name: String, country_code: String, phone_number: String) -> Self {
Self {
name,
country_code,
phone_number,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct WebhookNotification {
#[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
pub service_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<serde_json::Value>,
}
impl WebhookNotification {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebhookReceiver {
pub name: String,
#[serde(rename = "serviceUri")]
pub service_uri: String,
}
impl WebhookReceiver {
pub fn new(name: String, service_uri: String) -> Self {
Self { name, service_uri }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebtestLocationAvailabilityCriteria {
#[serde(flatten)]
pub metric_alert_criteria: MetricAlertCriteria,
#[serde(rename = "webTestId")]
pub web_test_id: String,
#[serde(rename = "componentId")]
pub component_id: String,
#[serde(rename = "failedLocationCount")]
pub failed_location_count: f64,
}
impl WebtestLocationAvailabilityCriteria {
pub fn new(metric_alert_criteria: MetricAlertCriteria, web_test_id: String, component_id: String, failed_location_count: f64) -> Self {
Self {
metric_alert_criteria,
web_test_id,
component_id,
failed_location_count,
}
}
}