/* 
 * Sematext Cloud API
 *
 * API Explorer provides access and documentation for Sematext REST API. The REST API requires the API Key to be sent as part of `Authorization` header. E.g.: `Authorization : apiKey e5f18450-205a-48eb-8589-7d49edaea813`.
 *
 * OpenAPI spec version: v3
 * 
 * Generated by: https://github.com/swagger-api/swagger-codegen.git
 */


#[allow(unused_imports)]
use serde_json::Value;

#[derive(Debug, Serialize, Deserialize)]
pub struct DayUsageData {
  #[serde(rename = "countDailyDataPoints")]
  count_daily_data_points: Option<i32>,
  #[serde(rename = "day")]
  day: Option<String>,
  #[serde(rename = "discount")]
  discount: Option<f32>,
  #[serde(rename = "dpmPerContainerHostQuota")]
  dpm_per_container_host_quota: Option<i64>,
  #[serde(rename = "dpmPerHostQuota")]
  dpm_per_host_quota: Option<i64>,
  #[serde(rename = "fixedMonthlyPrice")]
  fixed_monthly_price: Option<f32>,
  #[serde(rename = "fixedMonthlyPricePerHour")]
  fixed_monthly_price_per_hour: Option<f32>,
  #[serde(rename = "freeContainersPerHost")]
  free_containers_per_host: Option<i32>,
  #[serde(rename = "id")]
  id: Option<i64>,
  #[serde(rename = "kiloDpmOveragePricePerHour")]
  kilo_dpm_overage_price_per_hour: Option<f32>,
  #[serde(rename = "planType")]
  plan_type: Option<String>,
  #[serde(rename = "pricePerContainerHostHour")]
  price_per_container_host_hour: Option<f32>,
  #[serde(rename = "pricePerContainerHour")]
  price_per_container_hour: Option<f32>,
  #[serde(rename = "pricePerServerHour")]
  price_per_server_hour: Option<f32>,
  #[serde(rename = "sumNumberOfContainerHosts")]
  sum_number_of_container_hosts: Option<i32>,
  #[serde(rename = "sumNumberOfContainers")]
  sum_number_of_containers: Option<i32>,
  #[serde(rename = "sumNumberOfServers")]
  sum_number_of_servers: Option<i32>,
  #[serde(rename = "usageAmount")]
  usage_amount: Option<f32>,
  #[serde(rename = "usedPlan")]
  used_plan: Option<String>,
  #[serde(rename = "userDiscount")]
  user_discount: Option<f32>
}

impl DayUsageData {
  pub fn new() -> DayUsageData {
    DayUsageData {
      count_daily_data_points: None,
      day: None,
      discount: None,
      dpm_per_container_host_quota: None,
      dpm_per_host_quota: None,
      fixed_monthly_price: None,
      fixed_monthly_price_per_hour: None,
      free_containers_per_host: None,
      id: None,
      kilo_dpm_overage_price_per_hour: None,
      plan_type: None,
      price_per_container_host_hour: None,
      price_per_container_hour: None,
      price_per_server_hour: None,
      sum_number_of_container_hosts: None,
      sum_number_of_containers: None,
      sum_number_of_servers: None,
      usage_amount: None,
      used_plan: None,
      user_discount: None
    }
  }

  pub fn set_count_daily_data_points(&mut self, count_daily_data_points: i32) {
    self.count_daily_data_points = Some(count_daily_data_points);
  }

  pub fn with_count_daily_data_points(mut self, count_daily_data_points: i32) -> DayUsageData {
    self.count_daily_data_points = Some(count_daily_data_points);
    self
  }

  pub fn count_daily_data_points(&self) -> Option<&i32> {
    self.count_daily_data_points.as_ref()
  }

  pub fn reset_count_daily_data_points(&mut self) {
    self.count_daily_data_points = None;
  }

  pub fn set_day(&mut self, day: String) {
    self.day = Some(day);
  }

  pub fn with_day(mut self, day: String) -> DayUsageData {
    self.day = Some(day);
    self
  }

  pub fn day(&self) -> Option<&String> {
    self.day.as_ref()
  }

  pub fn reset_day(&mut self) {
    self.day = None;
  }

  pub fn set_discount(&mut self, discount: f32) {
    self.discount = Some(discount);
  }

  pub fn with_discount(mut self, discount: f32) -> DayUsageData {
    self.discount = Some(discount);
    self
  }

  pub fn discount(&self) -> Option<&f32> {
    self.discount.as_ref()
  }

  pub fn reset_discount(&mut self) {
    self.discount = None;
  }

  pub fn set_dpm_per_container_host_quota(&mut self, dpm_per_container_host_quota: i64) {
    self.dpm_per_container_host_quota = Some(dpm_per_container_host_quota);
  }

  pub fn with_dpm_per_container_host_quota(mut self, dpm_per_container_host_quota: i64) -> DayUsageData {
    self.dpm_per_container_host_quota = Some(dpm_per_container_host_quota);
    self
  }

  pub fn dpm_per_container_host_quota(&self) -> Option<&i64> {
    self.dpm_per_container_host_quota.as_ref()
  }

  pub fn reset_dpm_per_container_host_quota(&mut self) {
    self.dpm_per_container_host_quota = None;
  }

  pub fn set_dpm_per_host_quota(&mut self, dpm_per_host_quota: i64) {
    self.dpm_per_host_quota = Some(dpm_per_host_quota);
  }

  pub fn with_dpm_per_host_quota(mut self, dpm_per_host_quota: i64) -> DayUsageData {
    self.dpm_per_host_quota = Some(dpm_per_host_quota);
    self
  }

  pub fn dpm_per_host_quota(&self) -> Option<&i64> {
    self.dpm_per_host_quota.as_ref()
  }

  pub fn reset_dpm_per_host_quota(&mut self) {
    self.dpm_per_host_quota = None;
  }

  pub fn set_fixed_monthly_price(&mut self, fixed_monthly_price: f32) {
    self.fixed_monthly_price = Some(fixed_monthly_price);
  }

  pub fn with_fixed_monthly_price(mut self, fixed_monthly_price: f32) -> DayUsageData {
    self.fixed_monthly_price = Some(fixed_monthly_price);
    self
  }

  pub fn fixed_monthly_price(&self) -> Option<&f32> {
    self.fixed_monthly_price.as_ref()
  }

  pub fn reset_fixed_monthly_price(&mut self) {
    self.fixed_monthly_price = None;
  }

  pub fn set_fixed_monthly_price_per_hour(&mut self, fixed_monthly_price_per_hour: f32) {
    self.fixed_monthly_price_per_hour = Some(fixed_monthly_price_per_hour);
  }

  pub fn with_fixed_monthly_price_per_hour(mut self, fixed_monthly_price_per_hour: f32) -> DayUsageData {
    self.fixed_monthly_price_per_hour = Some(fixed_monthly_price_per_hour);
    self
  }

  pub fn fixed_monthly_price_per_hour(&self) -> Option<&f32> {
    self.fixed_monthly_price_per_hour.as_ref()
  }

  pub fn reset_fixed_monthly_price_per_hour(&mut self) {
    self.fixed_monthly_price_per_hour = None;
  }

  pub fn set_free_containers_per_host(&mut self, free_containers_per_host: i32) {
    self.free_containers_per_host = Some(free_containers_per_host);
  }

  pub fn with_free_containers_per_host(mut self, free_containers_per_host: i32) -> DayUsageData {
    self.free_containers_per_host = Some(free_containers_per_host);
    self
  }

  pub fn free_containers_per_host(&self) -> Option<&i32> {
    self.free_containers_per_host.as_ref()
  }

  pub fn reset_free_containers_per_host(&mut self) {
    self.free_containers_per_host = None;
  }

  pub fn set_id(&mut self, id: i64) {
    self.id = Some(id);
  }

  pub fn with_id(mut self, id: i64) -> DayUsageData {
    self.id = Some(id);
    self
  }

  pub fn id(&self) -> Option<&i64> {
    self.id.as_ref()
  }

  pub fn reset_id(&mut self) {
    self.id = None;
  }

  pub fn set_kilo_dpm_overage_price_per_hour(&mut self, kilo_dpm_overage_price_per_hour: f32) {
    self.kilo_dpm_overage_price_per_hour = Some(kilo_dpm_overage_price_per_hour);
  }

  pub fn with_kilo_dpm_overage_price_per_hour(mut self, kilo_dpm_overage_price_per_hour: f32) -> DayUsageData {
    self.kilo_dpm_overage_price_per_hour = Some(kilo_dpm_overage_price_per_hour);
    self
  }

  pub fn kilo_dpm_overage_price_per_hour(&self) -> Option<&f32> {
    self.kilo_dpm_overage_price_per_hour.as_ref()
  }

  pub fn reset_kilo_dpm_overage_price_per_hour(&mut self) {
    self.kilo_dpm_overage_price_per_hour = None;
  }

  pub fn set_plan_type(&mut self, plan_type: String) {
    self.plan_type = Some(plan_type);
  }

  pub fn with_plan_type(mut self, plan_type: String) -> DayUsageData {
    self.plan_type = Some(plan_type);
    self
  }

  pub fn plan_type(&self) -> Option<&String> {
    self.plan_type.as_ref()
  }

  pub fn reset_plan_type(&mut self) {
    self.plan_type = None;
  }

  pub fn set_price_per_container_host_hour(&mut self, price_per_container_host_hour: f32) {
    self.price_per_container_host_hour = Some(price_per_container_host_hour);
  }

  pub fn with_price_per_container_host_hour(mut self, price_per_container_host_hour: f32) -> DayUsageData {
    self.price_per_container_host_hour = Some(price_per_container_host_hour);
    self
  }

  pub fn price_per_container_host_hour(&self) -> Option<&f32> {
    self.price_per_container_host_hour.as_ref()
  }

  pub fn reset_price_per_container_host_hour(&mut self) {
    self.price_per_container_host_hour = None;
  }

  pub fn set_price_per_container_hour(&mut self, price_per_container_hour: f32) {
    self.price_per_container_hour = Some(price_per_container_hour);
  }

  pub fn with_price_per_container_hour(mut self, price_per_container_hour: f32) -> DayUsageData {
    self.price_per_container_hour = Some(price_per_container_hour);
    self
  }

  pub fn price_per_container_hour(&self) -> Option<&f32> {
    self.price_per_container_hour.as_ref()
  }

  pub fn reset_price_per_container_hour(&mut self) {
    self.price_per_container_hour = None;
  }

  pub fn set_price_per_server_hour(&mut self, price_per_server_hour: f32) {
    self.price_per_server_hour = Some(price_per_server_hour);
  }

  pub fn with_price_per_server_hour(mut self, price_per_server_hour: f32) -> DayUsageData {
    self.price_per_server_hour = Some(price_per_server_hour);
    self
  }

  pub fn price_per_server_hour(&self) -> Option<&f32> {
    self.price_per_server_hour.as_ref()
  }

  pub fn reset_price_per_server_hour(&mut self) {
    self.price_per_server_hour = None;
  }

  pub fn set_sum_number_of_container_hosts(&mut self, sum_number_of_container_hosts: i32) {
    self.sum_number_of_container_hosts = Some(sum_number_of_container_hosts);
  }

  pub fn with_sum_number_of_container_hosts(mut self, sum_number_of_container_hosts: i32) -> DayUsageData {
    self.sum_number_of_container_hosts = Some(sum_number_of_container_hosts);
    self
  }

  pub fn sum_number_of_container_hosts(&self) -> Option<&i32> {
    self.sum_number_of_container_hosts.as_ref()
  }

  pub fn reset_sum_number_of_container_hosts(&mut self) {
    self.sum_number_of_container_hosts = None;
  }

  pub fn set_sum_number_of_containers(&mut self, sum_number_of_containers: i32) {
    self.sum_number_of_containers = Some(sum_number_of_containers);
  }

  pub fn with_sum_number_of_containers(mut self, sum_number_of_containers: i32) -> DayUsageData {
    self.sum_number_of_containers = Some(sum_number_of_containers);
    self
  }

  pub fn sum_number_of_containers(&self) -> Option<&i32> {
    self.sum_number_of_containers.as_ref()
  }

  pub fn reset_sum_number_of_containers(&mut self) {
    self.sum_number_of_containers = None;
  }

  pub fn set_sum_number_of_servers(&mut self, sum_number_of_servers: i32) {
    self.sum_number_of_servers = Some(sum_number_of_servers);
  }

  pub fn with_sum_number_of_servers(mut self, sum_number_of_servers: i32) -> DayUsageData {
    self.sum_number_of_servers = Some(sum_number_of_servers);
    self
  }

  pub fn sum_number_of_servers(&self) -> Option<&i32> {
    self.sum_number_of_servers.as_ref()
  }

  pub fn reset_sum_number_of_servers(&mut self) {
    self.sum_number_of_servers = None;
  }

  pub fn set_usage_amount(&mut self, usage_amount: f32) {
    self.usage_amount = Some(usage_amount);
  }

  pub fn with_usage_amount(mut self, usage_amount: f32) -> DayUsageData {
    self.usage_amount = Some(usage_amount);
    self
  }

  pub fn usage_amount(&self) -> Option<&f32> {
    self.usage_amount.as_ref()
  }

  pub fn reset_usage_amount(&mut self) {
    self.usage_amount = None;
  }

  pub fn set_used_plan(&mut self, used_plan: String) {
    self.used_plan = Some(used_plan);
  }

  pub fn with_used_plan(mut self, used_plan: String) -> DayUsageData {
    self.used_plan = Some(used_plan);
    self
  }

  pub fn used_plan(&self) -> Option<&String> {
    self.used_plan.as_ref()
  }

  pub fn reset_used_plan(&mut self) {
    self.used_plan = None;
  }

  pub fn set_user_discount(&mut self, user_discount: f32) {
    self.user_discount = Some(user_discount);
  }

  pub fn with_user_discount(mut self, user_discount: f32) -> DayUsageData {
    self.user_discount = Some(user_discount);
    self
  }

  pub fn user_discount(&self) -> Option<&f32> {
    self.user_discount.as_ref()
  }

  pub fn reset_user_discount(&mut self) {
    self.user_discount = None;
  }

}