ib 3.0.0

/* 
 * Client Portal Web API
 *
 * Client Poral Web API
 *
 * OpenAPI spec version: 1.0.0
 * 
 * Generated by: https://github.com/swagger-api/swagger-codegen.git
 */


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

#[derive(Debug, Serialize, Deserialize)]
pub struct TransactionsTransactions {
  #[serde(rename = "acctid")]
  acctid: Option<String>,
  /// Raw value, no formatting. Transaction amount. For trades does not include commission. In asset currency
  #[serde(rename = "amt")]
  amt: Option<f32>,
  #[serde(rename = "conid")]
  conid: Option<f32>,
  /// currency code
  #[serde(rename = "cur")]
  cur: Option<String>,
  /// Date of transaction.  Epoch time, GMT
  #[serde(rename = "date")]
  date: Option<String>,
  /// Transaction description
  #[serde(rename = "desc")]
  desc: Option<String>,
  /// Conversion rate from asset currency to response currency
  #[serde(rename = "fxRate")]
  fx_rate: Option<f32>,
  /// In asset currency. Not be applicable for all transaction types.
  #[serde(rename = "pr")]
  pr: Option<f32>,
  /// Not applicable for all transaction types
  #[serde(rename = "qty")]
  qty: Option<f32>,
  /// Transaction Type Name: Examples: \"Sell\", \"Buy\", \"Corporate Action\", \"Dividend Payment\", \"Transfer\", \"Payment in Lieu\" Dividends and Transfers do not have price and quantity in response 
  #[serde(rename = "type")]
  _type: Option<String>
}

impl TransactionsTransactions {
  pub fn new() -> TransactionsTransactions {
    TransactionsTransactions {
      acctid: None,
      amt: None,
      conid: None,
      cur: None,
      date: None,
      desc: None,
      fx_rate: None,
      pr: None,
      qty: None,
      _type: None
    }
  }

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

  pub fn with_acctid(mut self, acctid: String) -> TransactionsTransactions {
    self.acctid = Some(acctid);
    self
  }

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

  pub fn reset_acctid(&mut self) {
    self.acctid = None;
  }

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

  pub fn with_amt(mut self, amt: f32) -> TransactionsTransactions {
    self.amt = Some(amt);
    self
  }

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

  pub fn reset_amt(&mut self) {
    self.amt = None;
  }

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

  pub fn with_conid(mut self, conid: f32) -> TransactionsTransactions {
    self.conid = Some(conid);
    self
  }

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

  pub fn reset_conid(&mut self) {
    self.conid = None;
  }

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

  pub fn with_cur(mut self, cur: String) -> TransactionsTransactions {
    self.cur = Some(cur);
    self
  }

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

  pub fn reset_cur(&mut self) {
    self.cur = None;
  }

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

  pub fn with_date(mut self, date: String) -> TransactionsTransactions {
    self.date = Some(date);
    self
  }

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

  pub fn reset_date(&mut self) {
    self.date = None;
  }

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

  pub fn with_desc(mut self, desc: String) -> TransactionsTransactions {
    self.desc = Some(desc);
    self
  }

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

  pub fn reset_desc(&mut self) {
    self.desc = None;
  }

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

  pub fn with_fx_rate(mut self, fx_rate: f32) -> TransactionsTransactions {
    self.fx_rate = Some(fx_rate);
    self
  }

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

  pub fn reset_fx_rate(&mut self) {
    self.fx_rate = None;
  }

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

  pub fn with_pr(mut self, pr: f32) -> TransactionsTransactions {
    self.pr = Some(pr);
    self
  }

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

  pub fn reset_pr(&mut self) {
    self.pr = None;
  }

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

  pub fn with_qty(mut self, qty: f32) -> TransactionsTransactions {
    self.qty = Some(qty);
    self
  }

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

  pub fn reset_qty(&mut self) {
    self.qty = None;
  }

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

  pub fn with__type(mut self, _type: String) -> TransactionsTransactions {
    self._type = Some(_type);
    self
  }

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

  pub fn reset__type(&mut self) {
    self._type = None;
  }

}