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 InlineResponse20023String {
  /// Limit Price value
  #[serde(rename = "LP")]
  LP: Option<String>,
  /// Outside of Regular Trading Hours
  #[serde(rename = "ORTH")]
  ORTH: Option<bool>,
  /// Price Cap value
  #[serde(rename = "PC")]
  PC: Option<String>,
  /// Releative offset amount
  #[serde(rename = "ROA")]
  ROA: Option<String>,
  /// Relative offset percent
  #[serde(rename = "ROP")]
  ROP: Option<String>,
  /// Stop Price value
  #[serde(rename = "SP")]
  SP: Option<String>,
  /// Trailing amount value
  #[serde(rename = "TA")]
  TA: Option<String>,
  /// Touch trigger price
  #[serde(rename = "TT")]
  TT: Option<String>,
  /// Trailing unit
  #[serde(rename = "TU")]
  TU: Option<String>,
  /// Use Net Price for Bonds
  #[serde(rename = "UNP")]
  UNP: Option<bool>
}

impl InlineResponse20023String {
  pub fn new() -> InlineResponse20023String {
    InlineResponse20023String {
      LP: None,
      ORTH: None,
      PC: None,
      ROA: None,
      ROP: None,
      SP: None,
      TA: None,
      TT: None,
      TU: None,
      UNP: None
    }
  }

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

  pub fn with_LP(mut self, LP: String) -> InlineResponse20023String {
    self.LP = Some(LP);
    self
  }

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

  pub fn reset_LP(&mut self) {
    self.LP = None;
  }

  pub fn set_ORTH(&mut self, ORTH: bool) {
    self.ORTH = Some(ORTH);
  }

  pub fn with_ORTH(mut self, ORTH: bool) -> InlineResponse20023String {
    self.ORTH = Some(ORTH);
    self
  }

  pub fn ORTH(&self) -> Option<&bool> {
    self.ORTH.as_ref()
  }

  pub fn reset_ORTH(&mut self) {
    self.ORTH = None;
  }

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

  pub fn with_PC(mut self, PC: String) -> InlineResponse20023String {
    self.PC = Some(PC);
    self
  }

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

  pub fn reset_PC(&mut self) {
    self.PC = None;
  }

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

  pub fn with_ROA(mut self, ROA: String) -> InlineResponse20023String {
    self.ROA = Some(ROA);
    self
  }

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

  pub fn reset_ROA(&mut self) {
    self.ROA = None;
  }

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

  pub fn with_ROP(mut self, ROP: String) -> InlineResponse20023String {
    self.ROP = Some(ROP);
    self
  }

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

  pub fn reset_ROP(&mut self) {
    self.ROP = None;
  }

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

  pub fn with_SP(mut self, SP: String) -> InlineResponse20023String {
    self.SP = Some(SP);
    self
  }

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

  pub fn reset_SP(&mut self) {
    self.SP = None;
  }

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

  pub fn with_TA(mut self, TA: String) -> InlineResponse20023String {
    self.TA = Some(TA);
    self
  }

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

  pub fn reset_TA(&mut self) {
    self.TA = None;
  }

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

  pub fn with_TT(mut self, TT: String) -> InlineResponse20023String {
    self.TT = Some(TT);
    self
  }

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

  pub fn reset_TT(&mut self) {
    self.TT = None;
  }

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

  pub fn with_TU(mut self, TU: String) -> InlineResponse20023String {
    self.TU = Some(TU);
    self
  }

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

  pub fn reset_TU(&mut self) {
    self.TU = None;
  }

  pub fn set_UNP(&mut self, UNP: bool) {
    self.UNP = Some(UNP);
  }

  pub fn with_UNP(mut self, UNP: bool) -> InlineResponse20023String {
    self.UNP = Some(UNP);
    self
  }

  pub fn UNP(&self) -> Option<&bool> {
    self.UNP.as_ref()
  }

  pub fn reset_UNP(&mut self) {
    self.UNP = None;
  }

}