public static SettlementTypeEnum GetSettlementType()
        {
            SettlementTypeEnum settlementTypeAgreement = 0;

            Console.WriteLine("Please indicate what type of settlement transaction you are making:");
            Console.WriteLine("- Buying");
            Console.WriteLine("- Selling");
            Console.WriteLine("");

            var settlementType = Console.ReadLine();

            Console.WriteLine("You have entered {0}", settlementType);
            Console.WriteLine();

            switch (settlementType.ToLower())
            {
            case "buying":
                settlementTypeAgreement = SettlementTypeEnum.Buying;
                break;

            case "selling":
                settlementTypeAgreement = SettlementTypeEnum.Selling;
                break;

            default:
                Console.WriteLine("You did not enter a valid settlement type, please try again!");
                GetSettlementType();
                break;
            }

            return(settlementTypeAgreement);
        }
 public SettlementMasterData()
 {
     StartingDate   = new DateTime(DateTime.Today.Year, 1, 1);
     EndingDate     = DateTime.Today;
     SettlementType = SettlementTypeEnum.UNITS;
 }
 public DirectionalLegUnderlyer(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList underlyerNodeList = xmlNode.SelectNodes("underlyer");
     if (underlyerNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in underlyerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 underlyerIDRef = item.Attributes["id"].Name;
                 Underlyer ob = Underlyer();
                 IDManager.SetID(underlyerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 underlyerIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 underlyer = new Underlyer(item);
             }
         }
     }
     
 
     XmlNodeList settlementTypeNodeList = xmlNode.SelectNodes("settlementType");
     if (settlementTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementTypeIDRef = item.Attributes["id"].Name;
                 SettlementTypeEnum ob = SettlementTypeEnum();
                 IDManager.SetID(settlementTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementType = new SettlementTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList settlementDateNodeList = xmlNode.SelectNodes("settlementDate");
     if (settlementDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementDateIDRef = item.Attributes["id"].Name;
                 AdjustableOrRelativeDate ob = AdjustableOrRelativeDate();
                 IDManager.SetID(settlementDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementDate = new AdjustableOrRelativeDate(item);
             }
         }
     }
     
 
     XmlNodeList settlementAmountNodeList = xmlNode.SelectNodes("settlementAmount");
     if (settlementAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(settlementAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList settlementCurrencyNodeList = xmlNode.SelectNodes("settlementCurrency");
     if (settlementCurrencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementCurrencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementCurrencyIDRef = item.Attributes["id"].Name;
                 Currency ob = Currency();
                 IDManager.SetID(settlementCurrencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementCurrencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementCurrency = new Currency(item);
             }
         }
     }
     
 
     XmlNodeList fxFeatureNodeList = xmlNode.SelectNodes("fxFeature");
     if (fxFeatureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxFeatureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxFeatureIDRef = item.Attributes["id"].Name;
                 FxFeature ob = FxFeature();
                 IDManager.SetID(fxFeatureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxFeatureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxFeature = new FxFeature(item);
             }
         }
     }
     
 
 }
 public OptionBaseExtended(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList premiumNodeList = xmlNode.SelectNodes("premium");
     if (premiumNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in premiumNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 premiumIDRef = item.Attributes["id"].Name;
                 Premium ob = Premium();
                 IDManager.SetID(premiumIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 premiumIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 premium = new Premium(item);
             }
         }
     }
     
 
     XmlNodeList exerciseNodeList = xmlNode.SelectNodes("exercise");
     if (exerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseIDRef = item.Attributes["id"].Name;
                 Exercise ob = Exercise();
                 IDManager.SetID(exerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exercise = new Exercise(item);
             }
         }
     }
     
 
     XmlNodeList americanExerciseNodeList = xmlNode.SelectNodes("americanExercise");
     if (americanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in americanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 americanExerciseIDRef = item.Attributes["id"].Name;
                 AmericanExercise ob = AmericanExercise();
                 IDManager.SetID(americanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 americanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 americanExercise = new AmericanExercise(item);
             }
         }
     }
     
 
     XmlNodeList bermudaExerciseNodeList = xmlNode.SelectNodes("bermudaExercise");
     if (bermudaExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in bermudaExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 bermudaExerciseIDRef = item.Attributes["id"].Name;
                 BermudaExercise ob = BermudaExercise();
                 IDManager.SetID(bermudaExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 bermudaExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 bermudaExercise = new BermudaExercise(item);
             }
         }
     }
     
 
     XmlNodeList europeanExerciseNodeList = xmlNode.SelectNodes("europeanExercise");
     if (europeanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in europeanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 europeanExerciseIDRef = item.Attributes["id"].Name;
                 EuropeanExercise ob = EuropeanExercise();
                 IDManager.SetID(europeanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 europeanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 europeanExercise = new EuropeanExercise(item);
             }
         }
     }
     
 
     XmlNodeList exerciseProcedureNodeList = xmlNode.SelectNodes("exerciseProcedure");
     if (exerciseProcedureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseProcedureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseProcedureIDRef = item.Attributes["id"].Name;
                 ExerciseProcedure ob = ExerciseProcedure();
                 IDManager.SetID(exerciseProcedureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseProcedureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseProcedure = new ExerciseProcedure(item);
             }
         }
     }
     
 
     XmlNodeList featureNodeList = xmlNode.SelectNodes("feature");
     if (featureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in featureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 featureIDRef = item.Attributes["id"].Name;
                 OptionFeature ob = OptionFeature();
                 IDManager.SetID(featureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 featureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 feature = new OptionFeature(item);
             }
         }
     }
     
 
     XmlNodeList notionalReferenceNodeList = xmlNode.SelectNodes("notionalReference");
     if (notionalReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in notionalReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notionalReferenceIDRef = item.Attributes["id"].Name;
                 NotionalAmountReference ob = NotionalAmountReference();
                 IDManager.SetID(notionalReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notionalReference = new NotionalAmountReference(item);
             }
         }
     }
     
 
     XmlNodeList notionalAmountNodeList = xmlNode.SelectNodes("notionalAmount");
     if (notionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in notionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notionalAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(notionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notionalAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList optionEntitlementNodeList = xmlNode.SelectNodes("optionEntitlement");
     if (optionEntitlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in optionEntitlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 optionEntitlementIDRef = item.Attributes["id"].Name;
                 PositiveDecimal ob = PositiveDecimal();
                 IDManager.SetID(optionEntitlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 optionEntitlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 optionEntitlement = new PositiveDecimal(item);
             }
         }
     }
     
 
     XmlNodeList entitlementCurrencyNodeList = xmlNode.SelectNodes("entitlementCurrency");
     if (entitlementCurrencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in entitlementCurrencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 entitlementCurrencyIDRef = item.Attributes["id"].Name;
                 Currency ob = Currency();
                 IDManager.SetID(entitlementCurrencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 entitlementCurrencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 entitlementCurrency = new Currency(item);
             }
         }
     }
     
 
     XmlNodeList numberOfOptionsNodeList = xmlNode.SelectNodes("numberOfOptions");
     if (numberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberOfOptionsIDRef = item.Attributes["id"].Name;
                 PositiveDecimal ob = PositiveDecimal();
                 IDManager.SetID(numberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 numberOfOptions = new PositiveDecimal(item);
             }
         }
     }
     
 
     XmlNodeList settlementTypeNodeList = xmlNode.SelectNodes("settlementType");
     if (settlementTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementTypeIDRef = item.Attributes["id"].Name;
                 SettlementTypeEnum ob = SettlementTypeEnum();
                 IDManager.SetID(settlementTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementType = new SettlementTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList settlementDateNodeList = xmlNode.SelectNodes("settlementDate");
     if (settlementDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementDateIDRef = item.Attributes["id"].Name;
                 AdjustableOrRelativeDate ob = AdjustableOrRelativeDate();
                 IDManager.SetID(settlementDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementDate = new AdjustableOrRelativeDate(item);
             }
         }
     }
     
 
     XmlNodeList settlementAmountNodeList = xmlNode.SelectNodes("settlementAmount");
     if (settlementAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(settlementAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList settlementCurrencyNodeList = xmlNode.SelectNodes("settlementCurrency");
     if (settlementCurrencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementCurrencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementCurrencyIDRef = item.Attributes["id"].Name;
                 Currency ob = Currency();
                 IDManager.SetID(settlementCurrencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementCurrencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementCurrency = new Currency(item);
             }
         }
     }
     
 
 }
 public EquityExerciseValuationSettlement(XmlNode xmlNode)
 {
     XmlNodeList equityEuropeanExerciseNodeList = xmlNode.SelectNodes("equityEuropeanExercise");
     if (equityEuropeanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityEuropeanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityEuropeanExerciseIDRef = item.Attributes["id"].Name;
                 EquityEuropeanExercise ob = EquityEuropeanExercise();
                 IDManager.SetID(equityEuropeanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityEuropeanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityEuropeanExercise = new EquityEuropeanExercise(item);
             }
         }
     }
     
 
     XmlNodeList equityAmericanExerciseNodeList = xmlNode.SelectNodes("equityAmericanExercise");
     if (equityAmericanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityAmericanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityAmericanExerciseIDRef = item.Attributes["id"].Name;
                 EquityAmericanExercise ob = EquityAmericanExercise();
                 IDManager.SetID(equityAmericanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityAmericanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityAmericanExercise = new EquityAmericanExercise(item);
             }
         }
     }
     
 
     XmlNodeList equityBermudaExerciseNodeList = xmlNode.SelectNodes("equityBermudaExercise");
     if (equityBermudaExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityBermudaExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityBermudaExerciseIDRef = item.Attributes["id"].Name;
                 EquityBermudaExercise ob = EquityBermudaExercise();
                 IDManager.SetID(equityBermudaExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityBermudaExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityBermudaExercise = new EquityBermudaExercise(item);
             }
         }
     }
     
 
     XmlNodeList automaticExerciseNodeList = xmlNode.SelectNodes("automaticExercise");
     if (automaticExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in automaticExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 automaticExerciseIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(automaticExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 automaticExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 automaticExercise = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList makeWholeProvisionsNodeList = xmlNode.SelectNodes("makeWholeProvisions");
     if (makeWholeProvisionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in makeWholeProvisionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 makeWholeProvisionsIDRef = item.Attributes["id"].Name;
                 MakeWholeProvisions ob = MakeWholeProvisions();
                 IDManager.SetID(makeWholeProvisionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 makeWholeProvisionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 makeWholeProvisions = new MakeWholeProvisions(item);
             }
         }
     }
     
 
     XmlNodeList prePaymentNodeList = xmlNode.SelectNodes("prePayment");
     if (prePaymentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in prePaymentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 prePaymentIDRef = item.Attributes["id"].Name;
                 PrePayment ob = PrePayment();
                 IDManager.SetID(prePaymentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 prePaymentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 prePayment = new PrePayment(item);
             }
         }
     }
     
 
     XmlNodeList equityValuationNodeList = xmlNode.SelectNodes("equityValuation");
     if (equityValuationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityValuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityValuationIDRef = item.Attributes["id"].Name;
                 EquityValuation ob = EquityValuation();
                 IDManager.SetID(equityValuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityValuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityValuation = new EquityValuation(item);
             }
         }
     }
     
 
     XmlNodeList settlementDateNodeList = xmlNode.SelectNodes("settlementDate");
     if (settlementDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementDateIDRef = item.Attributes["id"].Name;
                 AdjustableOrRelativeDate ob = AdjustableOrRelativeDate();
                 IDManager.SetID(settlementDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementDate = new AdjustableOrRelativeDate(item);
             }
         }
     }
     
 
     XmlNodeList settlementCurrencyNodeList = xmlNode.SelectNodes("settlementCurrency");
     if (settlementCurrencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementCurrencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementCurrencyIDRef = item.Attributes["id"].Name;
                 Currency ob = Currency();
                 IDManager.SetID(settlementCurrencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementCurrencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementCurrency = new Currency(item);
             }
         }
     }
     
 
     XmlNodeList settlementPriceSourceNodeList = xmlNode.SelectNodes("settlementPriceSource");
     if (settlementPriceSourceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementPriceSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementPriceSourceIDRef = item.Attributes["id"].Name;
                 SettlementPriceSource ob = SettlementPriceSource();
                 IDManager.SetID(settlementPriceSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementPriceSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementPriceSource = new SettlementPriceSource(item);
             }
         }
     }
     
 
     XmlNodeList settlementTypeNodeList = xmlNode.SelectNodes("settlementType");
     if (settlementTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementTypeIDRef = item.Attributes["id"].Name;
                 SettlementTypeEnum ob = SettlementTypeEnum();
                 IDManager.SetID(settlementTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementType = new SettlementTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList settlementMethodElectionDateNodeList = xmlNode.SelectNodes("settlementMethodElectionDate");
     if (settlementMethodElectionDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementMethodElectionDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementMethodElectionDateIDRef = item.Attributes["id"].Name;
                 AdjustableOrRelativeDate ob = AdjustableOrRelativeDate();
                 IDManager.SetID(settlementMethodElectionDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementMethodElectionDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementMethodElectionDate = new AdjustableOrRelativeDate(item);
             }
         }
     }
     
 
     XmlNodeList settlementMethodElectingPartyReferenceNodeList = xmlNode.SelectNodes("settlementMethodElectingPartyReference");
     if (settlementMethodElectingPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementMethodElectingPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementMethodElectingPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(settlementMethodElectingPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementMethodElectingPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementMethodElectingPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList settlementPriceDefaultElectionNodeList = xmlNode.SelectNodes("settlementPriceDefaultElection");
     if (settlementPriceDefaultElectionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementPriceDefaultElectionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementPriceDefaultElectionIDRef = item.Attributes["id"].Name;
                 SettlementPriceDefaultElection ob = SettlementPriceDefaultElection();
                 IDManager.SetID(settlementPriceDefaultElectionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementPriceDefaultElectionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementPriceDefaultElection = new SettlementPriceDefaultElection(item);
             }
         }
     }
     
 
 }
 public OptionExercise(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList optionSellerNodeList = xmlNode.SelectNodes("optionSeller");
     if (optionSellerNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in optionSellerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 optionSellerIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(optionSellerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 optionSellerIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 optionSeller = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList optionBuyerNodeList = xmlNode.SelectNodes("optionBuyer");
     if (optionBuyerNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in optionBuyerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 optionBuyerIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(optionBuyerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 optionBuyerIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 optionBuyer = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList originalTradeNodeList = xmlNode.SelectNodes("originalTrade");
     if (originalTradeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in originalTradeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 originalTradeIDRef = item.Attributes["id"].Name;
                 Trade ob = Trade();
                 IDManager.SetID(originalTradeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 originalTradeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 originalTrade = new Trade(item);
             }
         }
     }
     
 
     XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");
     
     foreach (XmlNode item in tradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tradeIdentifierIDRef = item.Attributes["id"].Name;
                 List<PartyTradeIdentifier> ob = new List<PartyTradeIdentifier>();
                 ob.Add(new PartyTradeIdentifier(item));
                 IDManager.SetID(tradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
             tradeIdentifier.Add(new PartyTradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList exerciseDateNodeList = xmlNode.SelectNodes("exerciseDate");
     if (exerciseDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(exerciseDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList exerciseTimeNodeList = xmlNode.SelectNodes("exerciseTime");
     if (exerciseTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseTimeIDRef = item.Attributes["id"].Name;
                 XsdTypeTime ob = XsdTypeTime();
                 IDManager.SetID(exerciseTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseTime = new XsdTypeTime(item);
             }
         }
     }
     
 
     XmlNodeList expiryNodeList = xmlNode.SelectNodes("expiry");
     if (expiryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in expiryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 expiryIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(expiryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 expiryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 expiry = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList fullExerciseNodeList = xmlNode.SelectNodes("fullExercise");
     if (fullExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fullExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fullExerciseIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(fullExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fullExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fullExercise = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList exerciseInNotionalAmountNodeList = xmlNode.SelectNodes("exerciseInNotionalAmount");
     if (exerciseInNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseInNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseInNotionalAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(exerciseInNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseInNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseInNotionalAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList outstandingNotionalAmountNodeList = xmlNode.SelectNodes("outstandingNotionalAmount");
     if (outstandingNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in outstandingNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 outstandingNotionalAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(outstandingNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 outstandingNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 outstandingNotionalAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList exerciseInNumberOfOptionsNodeList = xmlNode.SelectNodes("exerciseInNumberOfOptions");
     if (exerciseInNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseInNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseInNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(exerciseInNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseInNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseInNumberOfOptions = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList outstandingNumberOfOptionsNodeList = xmlNode.SelectNodes("outstandingNumberOfOptions");
     if (outstandingNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in outstandingNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 outstandingNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(outstandingNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 outstandingNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 outstandingNumberOfOptions = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList exerciseInNumberOfUnitsNodeList = xmlNode.SelectNodes("exerciseInNumberOfUnits");
     if (exerciseInNumberOfUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseInNumberOfUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseInNumberOfUnitsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(exerciseInNumberOfUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseInNumberOfUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseInNumberOfUnits = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList outstandingNumberOfUnitsNodeList = xmlNode.SelectNodes("outstandingNumberOfUnits");
     if (outstandingNumberOfUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in outstandingNumberOfUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 outstandingNumberOfUnitsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(outstandingNumberOfUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 outstandingNumberOfUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 outstandingNumberOfUnits = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList settlementTypeNodeList = xmlNode.SelectNodes("settlementType");
     if (settlementTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementTypeIDRef = item.Attributes["id"].Name;
                 SettlementTypeEnum ob = SettlementTypeEnum();
                 IDManager.SetID(settlementTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementType = new SettlementTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList cashSettlementNodeList = xmlNode.SelectNodes("cashSettlement");
     if (cashSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cashSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cashSettlementIDRef = item.Attributes["id"].Name;
                 SimplePayment ob = SimplePayment();
                 IDManager.SetID(cashSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cashSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cashSettlement = new SimplePayment(item);
             }
         }
     }
     
 
     XmlNodeList physicalSettlementNodeList = xmlNode.SelectNodes("physicalSettlement");
     if (physicalSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in physicalSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 physicalSettlementIDRef = item.Attributes["id"].Name;
                 PhysicalSettlement ob = PhysicalSettlement();
                 IDManager.SetID(physicalSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 physicalSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 physicalSettlement = new PhysicalSettlement(item);
             }
         }
     }
     
 
     XmlNodeList paymentNodeList = xmlNode.SelectNodes("payment");
     if (paymentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentIDRef = item.Attributes["id"].Name;
                 NonNegativePayment ob = NonNegativePayment();
                 IDManager.SetID(paymentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 payment = new NonNegativePayment(item);
             }
         }
     }
     
 
 }