public NullPayoff(XmlNode xmlNode)
 {
     XmlNodeList dateNodeList = xmlNode.SelectNodes("date");
     
     foreach (XmlNode item in dateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = new XsdTypeDate();
                 ob.Add(new XsdTypeDate(item));
                 IDManager.SetID(dateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dateIDRef = item.Attributes["href"].Name;
             }
             else
             {
             date.Add(new XsdTypeDate(item));
             }
         }
     }
     
 
 }
 public EventDate(XmlNode xmlNode)
 {
     XmlNodeList dateSingleNodeList = xmlNode.SelectNodes("dateSingle");
     if (dateSingleNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dateSingleNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dateSingleIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(dateSingleIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dateSingleIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dateSingle = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public ConvertibleBond(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList underlyingEquityNodeList = xmlNode.SelectNodes("underlyingEquity");
     if (underlyingEquityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in underlyingEquityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 underlyingEquityIDRef = item.Attributes["id"].Name;
                 EquityAsset ob = EquityAsset();
                 IDManager.SetID(underlyingEquityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 underlyingEquityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 underlyingEquity = new EquityAsset(item);
             }
         }
     }
     
 
     XmlNodeList redemptionDateNodeList = xmlNode.SelectNodes("redemptionDate");
     if (redemptionDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in redemptionDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 redemptionDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(redemptionDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 redemptionDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 redemptionDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public FutureValueAmount(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList calculationPeriodNumberOfDaysNodeList = xmlNode.SelectNodes("calculationPeriodNumberOfDays");
     if (calculationPeriodNumberOfDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodNumberOfDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(calculationPeriodNumberOfDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodNumberOfDays = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList valueDateNodeList = xmlNode.SelectNodes("valueDate");
     if (valueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(valueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public StepBase(XmlNode xmlNode)
 {
     XmlNodeList stepDateNodeList = xmlNode.SelectNodes("stepDate");
     if (stepDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in stepDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stepDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(stepDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stepDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 stepDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public CancellationEvent(XmlNode xmlNode)
 {
     XmlNodeList adjustedExerciseDateNodeList = xmlNode.SelectNodes("adjustedExerciseDate");
     if (adjustedExerciseDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedExerciseDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedExerciseDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedExerciseDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedExerciseDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedExerciseDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedEarlyTerminationDateNodeList = xmlNode.SelectNodes("adjustedEarlyTerminationDate");
     if (adjustedEarlyTerminationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedEarlyTerminationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedEarlyTerminationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedEarlyTerminationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedEarlyTerminationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedEarlyTerminationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public ContractualTermsSupplement(XmlNode xmlNode)
 {
     XmlNodeList typeNodeList = xmlNode.SelectNodes("type");
     if (typeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in typeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 typeIDRef = item.Attributes["id"].Name;
                 ContractualSupplement ob = ContractualSupplement();
                 IDManager.SetID(typeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 typeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 type = new ContractualSupplement(item);
             }
         }
     }
     
 
     XmlNodeList publicationDateNodeList = xmlNode.SelectNodes("publicationDate");
     if (publicationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in publicationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 publicationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(publicationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 publicationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 publicationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public SettledEntityMatrix(XmlNode xmlNode)
 {
     XmlNodeList matrixSourceNodeList = xmlNode.SelectNodes("matrixSource");
     if (matrixSourceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in matrixSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 matrixSourceIDRef = item.Attributes["id"].Name;
                 MatrixSource ob = MatrixSource();
                 IDManager.SetID(matrixSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 matrixSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 matrixSource = new MatrixSource(item);
             }
         }
     }
     
 
     XmlNodeList publicationDateNodeList = xmlNode.SelectNodes("publicationDate");
     if (publicationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in publicationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 publicationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(publicationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 publicationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 publicationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public TimeDimension(XmlNode xmlNode)
 {
     XmlNodeList tenorNodeList = xmlNode.SelectNodes("tenor");
     if (tenorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tenorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tenorIDRef = item.Attributes["id"].Name;
                 Period ob = Period();
                 IDManager.SetID(tenorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tenorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tenor = new Period(item);
             }
         }
     }
     
 
     XmlNodeList dateNodeList = xmlNode.SelectNodes("date");
     if (dateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(dateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 date = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public DateRange(XmlNode xmlNode)
 {
     XmlNodeList unadjustedFirstDateNodeList = xmlNode.SelectNodes("unadjustedFirstDate");
     if (unadjustedFirstDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in unadjustedFirstDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 unadjustedFirstDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(unadjustedFirstDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 unadjustedFirstDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 unadjustedFirstDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList unadjustedLastDateNodeList = xmlNode.SelectNodes("unadjustedLastDate");
     if (unadjustedLastDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in unadjustedLastDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 unadjustedLastDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(unadjustedLastDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 unadjustedLastDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 unadjustedLastDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public AdjustedPaymentDates(XmlNode xmlNode)
 {
     XmlNodeList adjustedPaymentDateNodeList = xmlNode.SelectNodes("adjustedPaymentDate");
     if (adjustedPaymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedPaymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedPaymentDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedPaymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedPaymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedPaymentDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList paymentAmountNodeList = xmlNode.SelectNodes("paymentAmount");
     if (paymentAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(paymentAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentAmount = new Money(item);
             }
         }
     }
     
 
 }
 public MakeWholeProvisions(XmlNode xmlNode)
 {
     XmlNodeList makeWholeDateNodeList = xmlNode.SelectNodes("makeWholeDate");
     if (makeWholeDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in makeWholeDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 makeWholeDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(makeWholeDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 makeWholeDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 makeWholeDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList recallSpreadNodeList = xmlNode.SelectNodes("recallSpread");
     if (recallSpreadNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in recallSpreadNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 recallSpreadIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(recallSpreadIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 recallSpreadIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 recallSpread = new XsdTypeDecimal(item);
             }
         }
     }
     
 
 }
 public TradeMaturity(XmlNode xmlNode)
 {
     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 dateNodeList = xmlNode.SelectNodes("date");
     if (dateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(dateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 date = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public TradeNovationContent(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList newTradeIdentifierNodeList = xmlNode.SelectNodes("newTradeIdentifier");
     
     foreach (XmlNode item in newTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 newTradeIdentifierIDRef = item.Attributes["id"].Name;
                 List<PartyTradeIdentifier> ob = new List<PartyTradeIdentifier>();
                 ob.Add(new PartyTradeIdentifier(item));
                 IDManager.SetID(newTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 newTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
             newTradeIdentifier.Add(new PartyTradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList newTradeNodeList = xmlNode.SelectNodes("newTrade");
     if (newTradeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in newTradeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 newTradeIDRef = item.Attributes["id"].Name;
                 Trade ob = Trade();
                 IDManager.SetID(newTradeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 newTradeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 newTrade = new Trade(item);
             }
         }
     }
     
 
     XmlNodeList oldTradeIdentifierNodeList = xmlNode.SelectNodes("oldTradeIdentifier");
     
     foreach (XmlNode item in oldTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 oldTradeIdentifierIDRef = item.Attributes["id"].Name;
                 List<PartyTradeIdentifier> ob = new List<PartyTradeIdentifier>();
                 ob.Add(new PartyTradeIdentifier(item));
                 IDManager.SetID(oldTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 oldTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
             oldTradeIdentifier.Add(new PartyTradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList oldTradeNodeList = xmlNode.SelectNodes("oldTrade");
     if (oldTradeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in oldTradeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 oldTradeIDRef = item.Attributes["id"].Name;
                 Trade ob = Trade();
                 IDManager.SetID(oldTradeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 oldTradeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 oldTrade = new Trade(item);
             }
         }
     }
     
 
     XmlNodeList feeTradeIdentifierNodeList = xmlNode.SelectNodes("feeTradeIdentifier");
     if (feeTradeIdentifierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in feeTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 feeTradeIdentifierIDRef = item.Attributes["id"].Name;
                 PartyTradeIdentifier ob = PartyTradeIdentifier();
                 IDManager.SetID(feeTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 feeTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 feeTradeIdentifier = new PartyTradeIdentifier(item);
             }
         }
     }
     
 
     XmlNodeList feeTradeNodeList = xmlNode.SelectNodes("feeTrade");
     if (feeTradeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in feeTradeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 feeTradeIDRef = item.Attributes["id"].Name;
                 Trade ob = Trade();
                 IDManager.SetID(feeTradeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 feeTradeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 feeTrade = new Trade(item);
             }
         }
     }
     
 
     XmlNodeList transferorNodeList = xmlNode.SelectNodes("transferor");
     if (transferorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in transferorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 transferorIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(transferorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 transferorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 transferor = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList transferorAccountNodeList = xmlNode.SelectNodes("transferorAccount");
     if (transferorAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in transferorAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 transferorAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(transferorAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 transferorAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 transferorAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList transfereeNodeList = xmlNode.SelectNodes("transferee");
     if (transfereeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in transfereeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 transfereeIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(transfereeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 transfereeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 transferee = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList otherTransfereeNodeList = xmlNode.SelectNodes("otherTransferee");
     if (otherTransfereeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherTransfereeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherTransfereeIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(otherTransfereeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherTransfereeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherTransferee = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList transfereeAccountNodeList = xmlNode.SelectNodes("transfereeAccount");
     if (transfereeAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in transfereeAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 transfereeAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(transfereeAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 transfereeAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 transfereeAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList otherTransfereeAccountNodeList = xmlNode.SelectNodes("otherTransfereeAccount");
     if (otherTransfereeAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherTransfereeAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherTransfereeAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(otherTransfereeAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherTransfereeAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherTransfereeAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList remainingPartyNodeList = xmlNode.SelectNodes("remainingParty");
     if (remainingPartyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in remainingPartyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingPartyIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(remainingPartyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingPartyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 remainingParty = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList remainingPartyAccountNodeList = xmlNode.SelectNodes("remainingPartyAccount");
     if (remainingPartyAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in remainingPartyAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingPartyAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(remainingPartyAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingPartyAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 remainingPartyAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList otherRemainingPartyNodeList = xmlNode.SelectNodes("otherRemainingParty");
     if (otherRemainingPartyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherRemainingPartyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherRemainingPartyIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(otherRemainingPartyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherRemainingPartyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherRemainingParty = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList otherRemainingPartyAccountNodeList = xmlNode.SelectNodes("otherRemainingPartyAccount");
     if (otherRemainingPartyAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherRemainingPartyAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherRemainingPartyAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(otherRemainingPartyAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherRemainingPartyAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherRemainingPartyAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList novationDateNodeList = xmlNode.SelectNodes("novationDate");
     if (novationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in novationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(novationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 novationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList executionDateTimeNodeList = xmlNode.SelectNodes("executionDateTime");
     if (executionDateTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in executionDateTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 executionDateTimeIDRef = item.Attributes["id"].Name;
                 ExecutionDateTime ob = ExecutionDateTime();
                 IDManager.SetID(executionDateTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 executionDateTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 executionDateTime = new ExecutionDateTime(item);
             }
         }
     }
     
 
     XmlNodeList novationTradeDateNodeList = xmlNode.SelectNodes("novationTradeDate");
     if (novationTradeDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in novationTradeDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novationTradeDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(novationTradeDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novationTradeDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 novationTradeDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList novatedAmountNodeList = xmlNode.SelectNodes("novatedAmount");
     
     foreach (XmlNode item in novatedAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novatedAmountIDRef = item.Attributes["id"].Name;
                 List<Money> ob = new List<Money>();
                 ob.Add(new Money(item));
                 IDManager.SetID(novatedAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novatedAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
             novatedAmount.Add(new Money(item));
             }
         }
     }
     
 
     XmlNodeList remainingAmountNodeList = xmlNode.SelectNodes("remainingAmount");
     
     foreach (XmlNode item in remainingAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingAmountIDRef = item.Attributes["id"].Name;
                 List<Money> ob = new List<Money>();
                 ob.Add(new Money(item));
                 IDManager.SetID(remainingAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
             remainingAmount.Add(new Money(item));
             }
         }
     }
     
 
     XmlNodeList novatedNumberOfOptionsNodeList = xmlNode.SelectNodes("novatedNumberOfOptions");
     if (novatedNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in novatedNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novatedNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(novatedNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novatedNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 novatedNumberOfOptions = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList remainingNumberOfOptionsNodeList = xmlNode.SelectNodes("remainingNumberOfOptions");
     if (remainingNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in remainingNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(remainingNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 remainingNumberOfOptions = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList novatedNumberOfUnitsNodeList = xmlNode.SelectNodes("novatedNumberOfUnits");
     if (novatedNumberOfUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in novatedNumberOfUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novatedNumberOfUnitsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(novatedNumberOfUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novatedNumberOfUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 novatedNumberOfUnits = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList remainingNumberOfUnitsNodeList = xmlNode.SelectNodes("remainingNumberOfUnits");
     if (remainingNumberOfUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in remainingNumberOfUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingNumberOfUnitsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(remainingNumberOfUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingNumberOfUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 remainingNumberOfUnits = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList fullFirstCalculationPeriodNodeList = xmlNode.SelectNodes("fullFirstCalculationPeriod");
     if (fullFirstCalculationPeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fullFirstCalculationPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fullFirstCalculationPeriodIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(fullFirstCalculationPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fullFirstCalculationPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fullFirstCalculationPeriod = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList firstPeriodStartDateNodeList = xmlNode.SelectNodes("firstPeriodStartDate");
     
     foreach (XmlNode item in firstPeriodStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 firstPeriodStartDateIDRef = item.Attributes["id"].Name;
                 List<FirstPeriodStartDate> ob = new List<FirstPeriodStartDate>();
                 ob.Add(new FirstPeriodStartDate(item));
                 IDManager.SetID(firstPeriodStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 firstPeriodStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
             firstPeriodStartDate.Add(new FirstPeriodStartDate(item));
             }
         }
     }
     
 
     XmlNodeList nonRelianceNodeList = xmlNode.SelectNodes("nonReliance");
     if (nonRelianceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nonRelianceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nonRelianceIDRef = item.Attributes["id"].Name;
                 Empty ob = Empty();
                 IDManager.SetID(nonRelianceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nonRelianceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 nonReliance = new Empty(item);
             }
         }
     }
     
 
     XmlNodeList creditDerivativesNoticesNodeList = xmlNode.SelectNodes("creditDerivativesNotices");
     if (creditDerivativesNoticesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditDerivativesNoticesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditDerivativesNoticesIDRef = item.Attributes["id"].Name;
                 CreditDerivativesNotices ob = CreditDerivativesNotices();
                 IDManager.SetID(creditDerivativesNoticesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditDerivativesNoticesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditDerivativesNotices = new CreditDerivativesNotices(item);
             }
         }
     }
     
 
     XmlNodeList contractualDefinitionsNodeList = xmlNode.SelectNodes("contractualDefinitions");
     
     foreach (XmlNode item in contractualDefinitionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 contractualDefinitionsIDRef = item.Attributes["id"].Name;
                 List<ContractualDefinitions> ob = new List<ContractualDefinitions>();
                 ob.Add(new ContractualDefinitions(item));
                 IDManager.SetID(contractualDefinitionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 contractualDefinitionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
             contractualDefinitions.Add(new ContractualDefinitions(item));
             }
         }
     }
     
 
     XmlNodeList contractualTermsSupplementNodeList = xmlNode.SelectNodes("contractualTermsSupplement");
     
     foreach (XmlNode item in contractualTermsSupplementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 contractualTermsSupplementIDRef = item.Attributes["id"].Name;
                 List<ContractualTermsSupplement> ob = new List<ContractualTermsSupplement>();
                 ob.Add(new ContractualTermsSupplement(item));
                 IDManager.SetID(contractualTermsSupplementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 contractualTermsSupplementIDRef = item.Attributes["href"].Name;
             }
             else
             {
             contractualTermsSupplement.Add(new ContractualTermsSupplement(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;
                 Payment ob = Payment();
                 IDManager.SetID(paymentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 payment = new Payment(item);
             }
         }
     }
     
 
 }
 public FxSingleLeg(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList exchangedCurrency1NodeList = xmlNode.SelectNodes("exchangedCurrency1");
     if (exchangedCurrency1NodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangedCurrency1NodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangedCurrency1IDRef = item.Attributes["id"].Name;
                 Payment ob = Payment();
                 IDManager.SetID(exchangedCurrency1IDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangedCurrency1IDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangedCurrency1 = new Payment(item);
             }
         }
     }
     
 
     XmlNodeList exchangedCurrency2NodeList = xmlNode.SelectNodes("exchangedCurrency2");
     if (exchangedCurrency2NodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangedCurrency2NodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangedCurrency2IDRef = item.Attributes["id"].Name;
                 Payment ob = Payment();
                 IDManager.SetID(exchangedCurrency2IDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangedCurrency2IDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangedCurrency2 = new Payment(item);
             }
         }
     }
     
 
     XmlNodeList dealtCurrencyNodeList = xmlNode.SelectNodes("dealtCurrency");
     if (dealtCurrencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dealtCurrencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dealtCurrencyIDRef = item.Attributes["id"].Name;
                 DealtCurrencyEnum ob = DealtCurrencyEnum();
                 IDManager.SetID(dealtCurrencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dealtCurrencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dealtCurrency = new DealtCurrencyEnum(item);
             }
         }
     }
     
 
     XmlNodeList tenorNameNodeList = xmlNode.SelectNodes("tenorName");
     if (tenorNameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tenorNameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tenorNameIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(tenorNameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tenorNameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tenorName = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList tenorPeriodNodeList = xmlNode.SelectNodes("tenorPeriod");
     if (tenorPeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tenorPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tenorPeriodIDRef = item.Attributes["id"].Name;
                 Period ob = Period();
                 IDManager.SetID(tenorPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tenorPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tenorPeriod = new Period(item);
             }
         }
     }
     
 
     XmlNodeList valueDateNodeList = xmlNode.SelectNodes("valueDate");
     if (valueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(valueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList currency1ValueDateNodeList = xmlNode.SelectNodes("currency1ValueDate");
     if (currency1ValueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currency1ValueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currency1ValueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(currency1ValueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currency1ValueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currency1ValueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList currency2ValueDateNodeList = xmlNode.SelectNodes("currency2ValueDate");
     if (currency2ValueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currency2ValueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currency2ValueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(currency2ValueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currency2ValueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currency2ValueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList exchangeRateNodeList = xmlNode.SelectNodes("exchangeRate");
     if (exchangeRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangeRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangeRateIDRef = item.Attributes["id"].Name;
                 ExchangeRate ob = ExchangeRate();
                 IDManager.SetID(exchangeRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangeRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangeRate = new ExchangeRate(item);
             }
         }
     }
     
 
     XmlNodeList nonDeliverableSettlementNodeList = xmlNode.SelectNodes("nonDeliverableSettlement");
     if (nonDeliverableSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nonDeliverableSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nonDeliverableSettlementIDRef = item.Attributes["id"].Name;
                 FxCashSettlement ob = FxCashSettlement();
                 IDManager.SetID(nonDeliverableSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nonDeliverableSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 nonDeliverableSettlement = new FxCashSettlement(item);
             }
         }
     }
     
 
 }
 public EquityDerivativeBase(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList buyerPartyReferenceNodeList = xmlNode.SelectNodes("buyerPartyReference");
     if (buyerPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in buyerPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 buyerPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(buyerPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 buyerPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 buyerPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList buyerAccountReferenceNodeList = xmlNode.SelectNodes("buyerAccountReference");
     if (buyerAccountReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in buyerAccountReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 buyerAccountReferenceIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(buyerAccountReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 buyerAccountReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 buyerAccountReference = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList sellerPartyReferenceNodeList = xmlNode.SelectNodes("sellerPartyReference");
     if (sellerPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sellerPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sellerPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(sellerPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sellerPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sellerPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList sellerAccountReferenceNodeList = xmlNode.SelectNodes("sellerAccountReference");
     if (sellerAccountReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sellerAccountReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sellerAccountReferenceIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(sellerAccountReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sellerAccountReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sellerAccountReference = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList optionTypeNodeList = xmlNode.SelectNodes("optionType");
     if (optionTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in optionTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 optionTypeIDRef = item.Attributes["id"].Name;
                 EquityOptionTypeEnum ob = EquityOptionTypeEnum();
                 IDManager.SetID(optionTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 optionTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 optionType = new EquityOptionTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList equityEffectiveDateNodeList = xmlNode.SelectNodes("equityEffectiveDate");
     if (equityEffectiveDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityEffectiveDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityEffectiveDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(equityEffectiveDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityEffectiveDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityEffectiveDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     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 notionalNodeList = xmlNode.SelectNodes("notional");
     if (notionalNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in notionalNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notionalIDRef = item.Attributes["id"].Name;
                 NonNegativeMoney ob = NonNegativeMoney();
                 IDManager.SetID(notionalIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notional = new NonNegativeMoney(item);
             }
         }
     }
     
 
     XmlNodeList equityExerciseNodeList = xmlNode.SelectNodes("equityExercise");
     if (equityExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityExerciseIDRef = item.Attributes["id"].Name;
                 EquityExerciseValuationSettlement ob = EquityExerciseValuationSettlement();
                 IDManager.SetID(equityExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityExercise = new EquityExerciseValuationSettlement(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;
                 OptionFeatures ob = OptionFeatures();
                 IDManager.SetID(featureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 featureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 feature = new OptionFeatures(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);
             }
         }
     }
     
 
     XmlNodeList strategyFeatureNodeList = xmlNode.SelectNodes("strategyFeature");
     if (strategyFeatureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in strategyFeatureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 strategyFeatureIDRef = item.Attributes["id"].Name;
                 StrategyFeature ob = StrategyFeature();
                 IDManager.SetID(strategyFeatureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 strategyFeatureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 strategyFeature = new StrategyFeature(item);
             }
         }
     }
     
 
 }
 public PaymentDates(XmlNode xmlNode)
 {
     XmlNodeList calculationPeriodDatesReferenceNodeList = xmlNode.SelectNodes("calculationPeriodDatesReference");
     if (calculationPeriodDatesReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodDatesReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodDatesReferenceIDRef = item.Attributes["id"].Name;
                 CalculationPeriodDatesReference ob = CalculationPeriodDatesReference();
                 IDManager.SetID(calculationPeriodDatesReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodDatesReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodDatesReference = new CalculationPeriodDatesReference(item);
             }
         }
     }
     
 
     XmlNodeList resetDatesReferenceNodeList = xmlNode.SelectNodes("resetDatesReference");
     if (resetDatesReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in resetDatesReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 resetDatesReferenceIDRef = item.Attributes["id"].Name;
                 ResetDatesReference ob = ResetDatesReference();
                 IDManager.SetID(resetDatesReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 resetDatesReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 resetDatesReference = new ResetDatesReference(item);
             }
         }
     }
     
 
     XmlNodeList valuationDatesReferenceNodeList = xmlNode.SelectNodes("valuationDatesReference");
     if (valuationDatesReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationDatesReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationDatesReferenceIDRef = item.Attributes["id"].Name;
                 ValuationDatesReference ob = ValuationDatesReference();
                 IDManager.SetID(valuationDatesReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationDatesReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationDatesReference = new ValuationDatesReference(item);
             }
         }
     }
     
 
     XmlNodeList paymentFrequencyNodeList = xmlNode.SelectNodes("paymentFrequency");
     if (paymentFrequencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentFrequencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentFrequencyIDRef = item.Attributes["id"].Name;
                 Frequency ob = Frequency();
                 IDManager.SetID(paymentFrequencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentFrequencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentFrequency = new Frequency(item);
             }
         }
     }
     
 
     XmlNodeList firstPaymentDateNodeList = xmlNode.SelectNodes("firstPaymentDate");
     if (firstPaymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in firstPaymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 firstPaymentDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(firstPaymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 firstPaymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 firstPaymentDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList lastRegularPaymentDateNodeList = xmlNode.SelectNodes("lastRegularPaymentDate");
     if (lastRegularPaymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in lastRegularPaymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 lastRegularPaymentDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(lastRegularPaymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 lastRegularPaymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 lastRegularPaymentDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList payRelativeToNodeList = xmlNode.SelectNodes("payRelativeTo");
     if (payRelativeToNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in payRelativeToNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 payRelativeToIDRef = item.Attributes["id"].Name;
                 PayRelativeToEnum ob = PayRelativeToEnum();
                 IDManager.SetID(payRelativeToIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 payRelativeToIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 payRelativeTo = new PayRelativeToEnum(item);
             }
         }
     }
     
 
     XmlNodeList paymentDaysOffsetNodeList = xmlNode.SelectNodes("paymentDaysOffset");
     if (paymentDaysOffsetNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentDaysOffsetNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentDaysOffsetIDRef = item.Attributes["id"].Name;
                 Offset ob = Offset();
                 IDManager.SetID(paymentDaysOffsetIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentDaysOffsetIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentDaysOffset = new Offset(item);
             }
         }
     }
     
 
     XmlNodeList paymentDatesAdjustmentsNodeList = xmlNode.SelectNodes("paymentDatesAdjustments");
     if (paymentDatesAdjustmentsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentDatesAdjustmentsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentDatesAdjustmentsIDRef = item.Attributes["id"].Name;
                 BusinessDayAdjustments ob = BusinessDayAdjustments();
                 IDManager.SetID(paymentDatesAdjustmentsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentDatesAdjustmentsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentDatesAdjustments = new BusinessDayAdjustments(item);
             }
         }
     }
     
 
 }
 public OptionExpiry(XmlNode xmlNode)
 : base(xmlNode)
 {
     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 dateNodeList = xmlNode.SelectNodes("date");
     if (dateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(dateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 date = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList timeNodeList = xmlNode.SelectNodes("time");
     if (timeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in timeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 timeIDRef = item.Attributes["id"].Name;
                 XsdTypeTime ob = XsdTypeTime();
                 IDManager.SetID(timeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 timeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 time = new XsdTypeTime(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;
                 ExerciseProcedureOption ob = ExerciseProcedureOption();
                 IDManager.SetID(exerciseProcedureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseProcedureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseProcedure = new ExerciseProcedureOption(item);
             }
         }
     }
     
 
 }
 public DeClear(XmlNode xmlNode)
 {
     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 effectiveDateNodeList = xmlNode.SelectNodes("effectiveDate");
     if (effectiveDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in effectiveDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 effectiveDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(effectiveDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 effectiveDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 effectiveDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList reasonNodeList = xmlNode.SelectNodes("reason");
     if (reasonNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in reasonNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 reasonIDRef = item.Attributes["id"].Name;
                 DeclearReason ob = DeclearReason();
                 IDManager.SetID(reasonIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 reasonIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 reason = new DeclearReason(item);
             }
         }
     }
     
 
 }
 public DualCurrencyFeature(XmlNode xmlNode)
 {
     XmlNodeList currencyNodeList = xmlNode.SelectNodes("currency");
     if (currencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currencyIDRef = item.Attributes["id"].Name;
                 Currency ob = Currency();
                 IDManager.SetID(currencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currency = new Currency(item);
             }
         }
     }
     
 
     XmlNodeList fixingDateNodeList = xmlNode.SelectNodes("fixingDate");
     if (fixingDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fixingDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fixingDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(fixingDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fixingDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fixingDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList fixingTimeNodeList = xmlNode.SelectNodes("fixingTime");
     if (fixingTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fixingTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fixingTimeIDRef = item.Attributes["id"].Name;
                 BusinessCenterTime ob = BusinessCenterTime();
                 IDManager.SetID(fixingTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fixingTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fixingTime = new BusinessCenterTime(item);
             }
         }
     }
     
 
     XmlNodeList strikeNodeList = xmlNode.SelectNodes("strike");
     if (strikeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in strikeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 strikeIDRef = item.Attributes["id"].Name;
                 DualCurrencyStrikePrice ob = DualCurrencyStrikePrice();
                 IDManager.SetID(strikeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 strikeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 strike = new DualCurrencyStrikePrice(item);
             }
         }
     }
     
 
     XmlNodeList spotRateNodeList = xmlNode.SelectNodes("spotRate");
     if (spotRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in spotRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 spotRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(spotRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 spotRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 spotRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList interestAtRiskNodeList = xmlNode.SelectNodes("interestAtRisk");
     if (interestAtRiskNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in interestAtRiskNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 interestAtRiskIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(interestAtRiskIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 interestAtRiskIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 interestAtRisk = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public CalculationPeriod(XmlNode xmlNode)
 {
     XmlNodeList unadjustedStartDateNodeList = xmlNode.SelectNodes("unadjustedStartDate");
     if (unadjustedStartDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in unadjustedStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 unadjustedStartDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(unadjustedStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 unadjustedStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 unadjustedStartDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList unadjustedEndDateNodeList = xmlNode.SelectNodes("unadjustedEndDate");
     if (unadjustedEndDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in unadjustedEndDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 unadjustedEndDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(unadjustedEndDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 unadjustedEndDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 unadjustedEndDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedStartDateNodeList = xmlNode.SelectNodes("adjustedStartDate");
     if (adjustedStartDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedStartDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedStartDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedEndDateNodeList = xmlNode.SelectNodes("adjustedEndDate");
     if (adjustedEndDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedEndDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedEndDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedEndDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedEndDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedEndDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList calculationPeriodNumberOfDaysNodeList = xmlNode.SelectNodes("calculationPeriodNumberOfDays");
     if (calculationPeriodNumberOfDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodNumberOfDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(calculationPeriodNumberOfDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodNumberOfDays = new XsdTypePositiveInteger(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;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(notionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notionalAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList fxLinkedNotionalAmountNodeList = xmlNode.SelectNodes("fxLinkedNotionalAmount");
     if (fxLinkedNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxLinkedNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxLinkedNotionalAmountIDRef = item.Attributes["id"].Name;
                 FxLinkedNotionalAmount ob = FxLinkedNotionalAmount();
                 IDManager.SetID(fxLinkedNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxLinkedNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxLinkedNotionalAmount = new FxLinkedNotionalAmount(item);
             }
         }
     }
     
 
     XmlNodeList floatingRateDefinitionNodeList = xmlNode.SelectNodes("floatingRateDefinition");
     if (floatingRateDefinitionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in floatingRateDefinitionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 floatingRateDefinitionIDRef = item.Attributes["id"].Name;
                 FloatingRateDefinition ob = FloatingRateDefinition();
                 IDManager.SetID(floatingRateDefinitionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 floatingRateDefinitionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 floatingRateDefinition = new FloatingRateDefinition(item);
             }
         }
     }
     
 
     XmlNodeList fixedRateNodeList = xmlNode.SelectNodes("fixedRate");
     if (fixedRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fixedRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fixedRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(fixedRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fixedRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fixedRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList dayCountYearFractionNodeList = xmlNode.SelectNodes("dayCountYearFraction");
     if (dayCountYearFractionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dayCountYearFractionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayCountYearFractionIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(dayCountYearFractionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayCountYearFractionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dayCountYearFraction = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList forecastAmountNodeList = xmlNode.SelectNodes("forecastAmount");
     if (forecastAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in forecastAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 forecastAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(forecastAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 forecastAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 forecastAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList forecastRateNodeList = xmlNode.SelectNodes("forecastRate");
     if (forecastRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in forecastRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 forecastRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(forecastRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 forecastRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 forecastRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
 }
 public FxEuropeanExercise(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList expiryDateNodeList = xmlNode.SelectNodes("expiryDate");
     if (expiryDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in expiryDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 expiryDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(expiryDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 expiryDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 expiryDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList expiryTimeNodeList = xmlNode.SelectNodes("expiryTime");
     if (expiryTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in expiryTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 expiryTimeIDRef = item.Attributes["id"].Name;
                 BusinessCenterTime ob = BusinessCenterTime();
                 IDManager.SetID(expiryTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 expiryTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 expiryTime = new BusinessCenterTime(item);
             }
         }
     }
     
 
     XmlNodeList cutNameNodeList = xmlNode.SelectNodes("cutName");
     if (cutNameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cutNameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cutNameIDRef = item.Attributes["id"].Name;
                 CutName ob = CutName();
                 IDManager.SetID(cutNameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cutNameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cutName = new CutName(item);
             }
         }
     }
     
 
     XmlNodeList valueDateNodeList = xmlNode.SelectNodes("valueDate");
     if (valueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(valueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public MultiDimensionalPricingData(XmlNode xmlNode)
 {
     XmlNodeList measureTypeNodeList = xmlNode.SelectNodes("measureType");
     if (measureTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in measureTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 measureTypeIDRef = item.Attributes["id"].Name;
                 AssetMeasureType ob = AssetMeasureType();
                 IDManager.SetID(measureTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 measureTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 measureType = new AssetMeasureType(item);
             }
         }
     }
     
 
     XmlNodeList quoteUnitsNodeList = xmlNode.SelectNodes("quoteUnits");
     if (quoteUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in quoteUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 quoteUnitsIDRef = item.Attributes["id"].Name;
                 PriceQuoteUnits ob = PriceQuoteUnits();
                 IDManager.SetID(quoteUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 quoteUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 quoteUnits = new PriceQuoteUnits(item);
             }
         }
     }
     
 
     XmlNodeList sideNodeList = xmlNode.SelectNodes("side");
     if (sideNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sideNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sideIDRef = item.Attributes["id"].Name;
                 QuotationSideEnum ob = QuotationSideEnum();
                 IDManager.SetID(sideIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sideIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 side = new QuotationSideEnum(item);
             }
         }
     }
     
 
     XmlNodeList currencyNodeList = xmlNode.SelectNodes("currency");
     if (currencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currencyIDRef = item.Attributes["id"].Name;
                 Currency ob = Currency();
                 IDManager.SetID(currencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currency = new Currency(item);
             }
         }
     }
     
 
     XmlNodeList currencyTypeNodeList = xmlNode.SelectNodes("currencyType");
     if (currencyTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currencyTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currencyTypeIDRef = item.Attributes["id"].Name;
                 ReportingCurrencyType ob = ReportingCurrencyType();
                 IDManager.SetID(currencyTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currencyTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currencyType = new ReportingCurrencyType(item);
             }
         }
     }
     
 
     XmlNodeList timingNodeList = xmlNode.SelectNodes("timing");
     if (timingNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in timingNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 timingIDRef = item.Attributes["id"].Name;
                 QuoteTiming ob = QuoteTiming();
                 IDManager.SetID(timingIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 timingIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 timing = new QuoteTiming(item);
             }
         }
     }
     
 
     XmlNodeList businessCenterNodeList = xmlNode.SelectNodes("businessCenter");
     if (businessCenterNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in businessCenterNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 businessCenterIDRef = item.Attributes["id"].Name;
                 BusinessCenter ob = BusinessCenter();
                 IDManager.SetID(businessCenterIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 businessCenterIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 businessCenter = new BusinessCenter(item);
             }
         }
     }
     
 
     XmlNodeList exchangeIdNodeList = xmlNode.SelectNodes("exchangeId");
     if (exchangeIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangeIdIDRef = item.Attributes["id"].Name;
                 ExchangeId ob = ExchangeId();
                 IDManager.SetID(exchangeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangeId = new ExchangeId(item);
             }
         }
     }
     
 
     XmlNodeList informationSourceNodeList = xmlNode.SelectNodes("informationSource");
     
     foreach (XmlNode item in informationSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 informationSourceIDRef = item.Attributes["id"].Name;
                 List<InformationSource> ob = new List<InformationSource>();
                 ob.Add(new InformationSource(item));
                 IDManager.SetID(informationSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 informationSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
             informationSource.Add(new InformationSource(item));
             }
         }
     }
     
 
     XmlNodeList pricingModelNodeList = xmlNode.SelectNodes("pricingModel");
     if (pricingModelNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in pricingModelNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pricingModelIDRef = item.Attributes["id"].Name;
                 PricingModel ob = PricingModel();
                 IDManager.SetID(pricingModelIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pricingModelIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 pricingModel = new PricingModel(item);
             }
         }
     }
     
 
     XmlNodeList timeNodeList = xmlNode.SelectNodes("time");
     if (timeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in timeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 timeIDRef = item.Attributes["id"].Name;
                 XsdTypeDateTime ob = XsdTypeDateTime();
                 IDManager.SetID(timeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 timeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 time = new XsdTypeDateTime(item);
             }
         }
     }
     
 
     XmlNodeList valuationDateNodeList = xmlNode.SelectNodes("valuationDate");
     if (valuationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(valuationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList expiryTimeNodeList = xmlNode.SelectNodes("expiryTime");
     if (expiryTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in expiryTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 expiryTimeIDRef = item.Attributes["id"].Name;
                 XsdTypeDateTime ob = XsdTypeDateTime();
                 IDManager.SetID(expiryTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 expiryTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 expiryTime = new XsdTypeDateTime(item);
             }
         }
     }
     
 
     XmlNodeList cashflowTypeNodeList = xmlNode.SelectNodes("cashflowType");
     if (cashflowTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cashflowTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cashflowTypeIDRef = item.Attributes["id"].Name;
                 CashflowType ob = CashflowType();
                 IDManager.SetID(cashflowTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cashflowTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cashflowType = new CashflowType(item);
             }
         }
     }
     
 
     XmlNodeList pointNodeList = xmlNode.SelectNodes("point");
     
     foreach (XmlNode item in pointNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pointIDRef = item.Attributes["id"].Name;
                 List<PricingStructurePoint> ob = new List<PricingStructurePoint>();
                 ob.Add(new PricingStructurePoint(item));
                 IDManager.SetID(pointIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pointIDRef = item.Attributes["href"].Name;
             }
             else
             {
             point.Add(new PricingStructurePoint(item));
             }
         }
     }
     
 
 }
 public InitialPayment(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList payerPartyReferenceNodeList = xmlNode.SelectNodes("payerPartyReference");
     if (payerPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in payerPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 payerPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(payerPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 payerPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 payerPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList payerAccountReferenceNodeList = xmlNode.SelectNodes("payerAccountReference");
     if (payerAccountReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in payerAccountReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 payerAccountReferenceIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(payerAccountReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 payerAccountReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 payerAccountReference = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList receiverPartyReferenceNodeList = xmlNode.SelectNodes("receiverPartyReference");
     if (receiverPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in receiverPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 receiverPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(receiverPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 receiverPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 receiverPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList receiverAccountReferenceNodeList = xmlNode.SelectNodes("receiverAccountReference");
     if (receiverAccountReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in receiverAccountReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 receiverAccountReferenceIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(receiverAccountReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 receiverAccountReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 receiverAccountReference = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList adjustablePaymentDateNodeList = xmlNode.SelectNodes("adjustablePaymentDate");
     if (adjustablePaymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustablePaymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustablePaymentDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustablePaymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustablePaymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustablePaymentDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedPaymentDateNodeList = xmlNode.SelectNodes("adjustedPaymentDate");
     if (adjustedPaymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedPaymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedPaymentDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedPaymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedPaymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedPaymentDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList paymentAmountNodeList = xmlNode.SelectNodes("paymentAmount");
     if (paymentAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(paymentAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentAmount = new Money(item);
             }
         }
     }
     
 
 }
 public Allocation(XmlNode xmlNode)
 {
     XmlNodeList allocationTradeIdNodeList = xmlNode.SelectNodes("allocationTradeId");
     
     foreach (XmlNode item in allocationTradeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 allocationTradeIdIDRef = item.Attributes["id"].Name;
                 List<TradeIdentifier> ob = new List<TradeIdentifier>();
                 ob.Add(new TradeIdentifier(item));
                 IDManager.SetID(allocationTradeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 allocationTradeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             allocationTradeId.Add(new TradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList partyReferenceNodeList = xmlNode.SelectNodes("partyReference");
     if (partyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in partyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 partyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(partyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 partyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 partyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList accountReferenceNodeList = xmlNode.SelectNodes("accountReference");
     if (accountReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in accountReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 accountReferenceIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(accountReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 accountReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 accountReference = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList allocatedFractionNodeList = xmlNode.SelectNodes("allocatedFraction");
     if (allocatedFractionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in allocatedFractionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 allocatedFractionIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(allocatedFractionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 allocatedFractionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 allocatedFraction = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList allocatedNotionalNodeList = xmlNode.SelectNodes("allocatedNotional");
     
     foreach (XmlNode item in allocatedNotionalNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 allocatedNotionalIDRef = item.Attributes["id"].Name;
                 List<Money> ob = new List<Money>();
                 ob.Add(new Money(item));
                 IDManager.SetID(allocatedNotionalIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 allocatedNotionalIDRef = item.Attributes["href"].Name;
             }
             else
             {
             allocatedNotional.Add(new Money(item));
             }
         }
     }
     
 
     XmlNodeList collateralNodeList = xmlNode.SelectNodes("collateral");
     if (collateralNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in collateralNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 collateralIDRef = item.Attributes["id"].Name;
                 Collateral ob = Collateral();
                 IDManager.SetID(collateralIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 collateralIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 collateral = new Collateral(item);
             }
         }
     }
     
 
     XmlNodeList creditChargeAmountNodeList = xmlNode.SelectNodes("creditChargeAmount");
     if (creditChargeAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditChargeAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditChargeAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(creditChargeAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditChargeAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditChargeAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList approvalsNodeList = xmlNode.SelectNodes("approvals");
     if (approvalsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in approvalsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 approvalsIDRef = item.Attributes["id"].Name;
                 Approvals ob = Approvals();
                 IDManager.SetID(approvalsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 approvalsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 approvals = new Approvals(item);
             }
         }
     }
     
 
     XmlNodeList masterConfirmationDateNodeList = xmlNode.SelectNodes("masterConfirmationDate");
     if (masterConfirmationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in masterConfirmationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 masterConfirmationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(masterConfirmationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 masterConfirmationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 masterConfirmationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList relatedPartyNodeList = xmlNode.SelectNodes("relatedParty");
     
     foreach (XmlNode item in relatedPartyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 relatedPartyIDRef = item.Attributes["id"].Name;
                 List<RelatedParty> ob = new List<RelatedParty>();
                 ob.Add(new RelatedParty(item));
                 IDManager.SetID(relatedPartyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 relatedPartyIDRef = item.Attributes["href"].Name;
             }
             else
             {
             relatedParty.Add(new RelatedParty(item));
             }
         }
     }
     
 
 }
 public FxBarrierFeature(XmlNode xmlNode)
 {
     XmlNodeList barrierTypeNodeList = xmlNode.SelectNodes("barrierType");
     if (barrierTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in barrierTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 barrierTypeIDRef = item.Attributes["id"].Name;
                 FxBarrierTypeEnum ob = FxBarrierTypeEnum();
                 IDManager.SetID(barrierTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 barrierTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 barrierType = new FxBarrierTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList quotedCurrencyPairNodeList = xmlNode.SelectNodes("quotedCurrencyPair");
     if (quotedCurrencyPairNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in quotedCurrencyPairNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 quotedCurrencyPairIDRef = item.Attributes["id"].Name;
                 QuotedCurrencyPair ob = QuotedCurrencyPair();
                 IDManager.SetID(quotedCurrencyPairIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 quotedCurrencyPairIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 quotedCurrencyPair = new QuotedCurrencyPair(item);
             }
         }
     }
     
 
     XmlNodeList triggerRateNodeList = xmlNode.SelectNodes("triggerRate");
     if (triggerRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in triggerRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 triggerRateIDRef = item.Attributes["id"].Name;
                 PositiveDecimal ob = PositiveDecimal();
                 IDManager.SetID(triggerRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 triggerRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 triggerRate = new PositiveDecimal(item);
             }
         }
     }
     
 
     XmlNodeList informationSourceNodeList = xmlNode.SelectNodes("informationSource");
     
     foreach (XmlNode item in informationSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 informationSourceIDRef = item.Attributes["id"].Name;
                 List<InformationSource> ob = new List<InformationSource>();
                 ob.Add(new InformationSource(item));
                 IDManager.SetID(informationSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 informationSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
             informationSource.Add(new InformationSource(item));
             }
         }
     }
     
 
     XmlNodeList observationStartDateNodeList = xmlNode.SelectNodes("observationStartDate");
     if (observationStartDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in observationStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 observationStartDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(observationStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 observationStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 observationStartDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList observationEndDateNodeList = xmlNode.SelectNodes("observationEndDate");
     if (observationEndDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in observationEndDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 observationEndDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(observationEndDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 observationEndDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 observationEndDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public Bond(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList issuerNameNodeList = xmlNode.SelectNodes("issuerName");
     if (issuerNameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in issuerNameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 issuerNameIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(issuerNameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 issuerNameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 issuerName = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList issuerPartyReferenceNodeList = xmlNode.SelectNodes("issuerPartyReference");
     if (issuerPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in issuerPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 issuerPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(issuerPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 issuerPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 issuerPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList seniorityNodeList = xmlNode.SelectNodes("seniority");
     if (seniorityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in seniorityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 seniorityIDRef = item.Attributes["id"].Name;
                 CreditSeniority ob = CreditSeniority();
                 IDManager.SetID(seniorityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 seniorityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 seniority = new CreditSeniority(item);
             }
         }
     }
     
 
     XmlNodeList couponTypeNodeList = xmlNode.SelectNodes("couponType");
     if (couponTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in couponTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 couponTypeIDRef = item.Attributes["id"].Name;
                 CouponType ob = CouponType();
                 IDManager.SetID(couponTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 couponTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 couponType = new CouponType(item);
             }
         }
     }
     
 
     XmlNodeList couponRateNodeList = xmlNode.SelectNodes("couponRate");
     if (couponRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in couponRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 couponRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(couponRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 couponRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 couponRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList maturityNodeList = xmlNode.SelectNodes("maturity");
     if (maturityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maturityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maturityIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(maturityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maturityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maturity = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList parValueNodeList = xmlNode.SelectNodes("parValue");
     if (parValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in parValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 parValueIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(parValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 parValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 parValue = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList faceAmountNodeList = xmlNode.SelectNodes("faceAmount");
     if (faceAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in faceAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 faceAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(faceAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 faceAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 faceAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList paymentFrequencyNodeList = xmlNode.SelectNodes("paymentFrequency");
     if (paymentFrequencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentFrequencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentFrequencyIDRef = item.Attributes["id"].Name;
                 Period ob = Period();
                 IDManager.SetID(paymentFrequencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentFrequencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentFrequency = new Period(item);
             }
         }
     }
     
 
     XmlNodeList dayCountFractionNodeList = xmlNode.SelectNodes("dayCountFraction");
     if (dayCountFractionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dayCountFractionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayCountFractionIDRef = item.Attributes["id"].Name;
                 DayCountFraction ob = DayCountFraction();
                 IDManager.SetID(dayCountFractionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayCountFractionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dayCountFraction = new DayCountFraction(item);
             }
         }
     }
     
 
 }
 public PrincipalExchange(XmlNode xmlNode)
 {
     XmlNodeList unadjustedPrincipalExchangeDateNodeList = xmlNode.SelectNodes("unadjustedPrincipalExchangeDate");
     if (unadjustedPrincipalExchangeDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in unadjustedPrincipalExchangeDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 unadjustedPrincipalExchangeDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(unadjustedPrincipalExchangeDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 unadjustedPrincipalExchangeDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 unadjustedPrincipalExchangeDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedPrincipalExchangeDateNodeList = xmlNode.SelectNodes("adjustedPrincipalExchangeDate");
     if (adjustedPrincipalExchangeDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedPrincipalExchangeDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedPrincipalExchangeDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedPrincipalExchangeDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedPrincipalExchangeDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedPrincipalExchangeDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList principalExchangeAmountNodeList = xmlNode.SelectNodes("principalExchangeAmount");
     if (principalExchangeAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in principalExchangeAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 principalExchangeAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(principalExchangeAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 principalExchangeAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 principalExchangeAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList discountFactorNodeList = xmlNode.SelectNodes("discountFactor");
     if (discountFactorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in discountFactorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 discountFactorIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(discountFactorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 discountFactorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 discountFactor = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList presentValuePrincipalExchangeAmountNodeList = xmlNode.SelectNodes("presentValuePrincipalExchangeAmount");
     if (presentValuePrincipalExchangeAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in presentValuePrincipalExchangeAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 presentValuePrincipalExchangeAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(presentValuePrincipalExchangeAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 presentValuePrincipalExchangeAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 presentValuePrincipalExchangeAmount = new Money(item);
             }
         }
     }
     
 
 }
 public CreditEventNoticeDocument(XmlNode xmlNode)
 {
     XmlNodeList affectedTransactionsNodeList = xmlNode.SelectNodes("affectedTransactions");
     if (affectedTransactionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in affectedTransactionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 affectedTransactionsIDRef = item.Attributes["id"].Name;
                 AffectedTransactions ob = AffectedTransactions();
                 IDManager.SetID(affectedTransactionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 affectedTransactionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 affectedTransactions = new AffectedTransactions(item);
             }
         }
     }
     
 
     XmlNodeList referenceEntityNodeList = xmlNode.SelectNodes("referenceEntity");
     if (referenceEntityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in referenceEntityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 referenceEntityIDRef = item.Attributes["id"].Name;
                 LegalEntity ob = LegalEntity();
                 IDManager.SetID(referenceEntityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 referenceEntityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 referenceEntity = new LegalEntity(item);
             }
         }
     }
     
 
     XmlNodeList creditEventNodeList = xmlNode.SelectNodes("creditEvent");
     if (creditEventNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditEventNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditEventIDRef = item.Attributes["id"].Name;
                 CreditEvent ob = CreditEvent();
                 IDManager.SetID(creditEventIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditEventIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditEvent = new CreditEvent(item);
             }
         }
     }
     
 
     XmlNodeList bankruptcyNodeList = xmlNode.SelectNodes("bankruptcy");
     if (bankruptcyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in bankruptcyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 bankruptcyIDRef = item.Attributes["id"].Name;
                 BankruptcyEvent ob = BankruptcyEvent();
                 IDManager.SetID(bankruptcyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 bankruptcyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 bankruptcy = new BankruptcyEvent(item);
             }
         }
     }
     
 
     XmlNodeList failureToPayNodeList = xmlNode.SelectNodes("failureToPay");
     if (failureToPayNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in failureToPayNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 failureToPayIDRef = item.Attributes["id"].Name;
                 FailureToPayEvent ob = FailureToPayEvent();
                 IDManager.SetID(failureToPayIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 failureToPayIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 failureToPay = new FailureToPayEvent(item);
             }
         }
     }
     
 
     XmlNodeList obligationAccelerationNodeList = xmlNode.SelectNodes("obligationAcceleration");
     if (obligationAccelerationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in obligationAccelerationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 obligationAccelerationIDRef = item.Attributes["id"].Name;
                 ObligationAccelerationEvent ob = ObligationAccelerationEvent();
                 IDManager.SetID(obligationAccelerationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 obligationAccelerationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 obligationAcceleration = new ObligationAccelerationEvent(item);
             }
         }
     }
     
 
     XmlNodeList obligationDefaultNodeList = xmlNode.SelectNodes("obligationDefault");
     if (obligationDefaultNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in obligationDefaultNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 obligationDefaultIDRef = item.Attributes["id"].Name;
                 ObligationDefaultEvent ob = ObligationDefaultEvent();
                 IDManager.SetID(obligationDefaultIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 obligationDefaultIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 obligationDefault = new ObligationDefaultEvent(item);
             }
         }
     }
     
 
     XmlNodeList repudiationMoratoriumNodeList = xmlNode.SelectNodes("repudiationMoratorium");
     if (repudiationMoratoriumNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in repudiationMoratoriumNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 repudiationMoratoriumIDRef = item.Attributes["id"].Name;
                 RepudiationMoratoriumEvent ob = RepudiationMoratoriumEvent();
                 IDManager.SetID(repudiationMoratoriumIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 repudiationMoratoriumIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 repudiationMoratorium = new RepudiationMoratoriumEvent(item);
             }
         }
     }
     
 
     XmlNodeList restructuringNodeList = xmlNode.SelectNodes("restructuring");
     if (restructuringNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in restructuringNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 restructuringIDRef = item.Attributes["id"].Name;
                 RestructuringEvent ob = RestructuringEvent();
                 IDManager.SetID(restructuringIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 restructuringIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 restructuring = new RestructuringEvent(item);
             }
         }
     }
     
 
     XmlNodeList publiclyAvailableInformationNodeList = xmlNode.SelectNodes("publiclyAvailableInformation");
     
     foreach (XmlNode item in publiclyAvailableInformationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 publiclyAvailableInformationIDRef = item.Attributes["id"].Name;
                 List<Resource> ob = new List<Resource>();
                 ob.Add(new Resource(item));
                 IDManager.SetID(publiclyAvailableInformationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 publiclyAvailableInformationIDRef = item.Attributes["href"].Name;
             }
             else
             {
             publiclyAvailableInformation.Add(new Resource(item));
             }
         }
     }
     
 
     XmlNodeList notifyingPartyReferenceNodeList = xmlNode.SelectNodes("notifyingPartyReference");
     if (notifyingPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in notifyingPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notifyingPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(notifyingPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notifyingPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notifyingPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList notifiedPartyReferenceNodeList = xmlNode.SelectNodes("notifiedPartyReference");
     if (notifiedPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in notifiedPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notifiedPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(notifiedPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notifiedPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notifiedPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList creditEventNoticeDateNodeList = xmlNode.SelectNodes("creditEventNoticeDate");
     if (creditEventNoticeDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditEventNoticeDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditEventNoticeDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(creditEventNoticeDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditEventNoticeDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditEventNoticeDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList creditEventDateNodeList = xmlNode.SelectNodes("creditEventDate");
     if (creditEventDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditEventDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditEventDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(creditEventDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditEventDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditEventDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public CalculationPeriodDates(XmlNode xmlNode)
 {
     XmlNodeList effectiveDateNodeList = xmlNode.SelectNodes("effectiveDate");
     if (effectiveDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in effectiveDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 effectiveDateIDRef = item.Attributes["id"].Name;
                 AdjustableDate ob = AdjustableDate();
                 IDManager.SetID(effectiveDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 effectiveDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 effectiveDate = new AdjustableDate(item);
             }
         }
     }
     
 
     XmlNodeList relativeEffectiveDateNodeList = xmlNode.SelectNodes("relativeEffectiveDate");
     if (relativeEffectiveDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in relativeEffectiveDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 relativeEffectiveDateIDRef = item.Attributes["id"].Name;
                 AdjustedRelativeDateOffset ob = AdjustedRelativeDateOffset();
                 IDManager.SetID(relativeEffectiveDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 relativeEffectiveDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 relativeEffectiveDate = new AdjustedRelativeDateOffset(item);
             }
         }
     }
     
 
     XmlNodeList terminationDateNodeList = xmlNode.SelectNodes("terminationDate");
     if (terminationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in terminationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 terminationDateIDRef = item.Attributes["id"].Name;
                 AdjustableDate ob = AdjustableDate();
                 IDManager.SetID(terminationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 terminationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 terminationDate = new AdjustableDate(item);
             }
         }
     }
     
 
     XmlNodeList relativeTerminationDateNodeList = xmlNode.SelectNodes("relativeTerminationDate");
     if (relativeTerminationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in relativeTerminationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 relativeTerminationDateIDRef = item.Attributes["id"].Name;
                 RelativeDateOffset ob = RelativeDateOffset();
                 IDManager.SetID(relativeTerminationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 relativeTerminationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 relativeTerminationDate = new RelativeDateOffset(item);
             }
         }
     }
     
 
     XmlNodeList calculationPeriodDatesAdjustmentsNodeList = xmlNode.SelectNodes("calculationPeriodDatesAdjustments");
     if (calculationPeriodDatesAdjustmentsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodDatesAdjustmentsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodDatesAdjustmentsIDRef = item.Attributes["id"].Name;
                 BusinessDayAdjustments ob = BusinessDayAdjustments();
                 IDManager.SetID(calculationPeriodDatesAdjustmentsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodDatesAdjustmentsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodDatesAdjustments = new BusinessDayAdjustments(item);
             }
         }
     }
     
 
     XmlNodeList firstPeriodStartDateNodeList = xmlNode.SelectNodes("firstPeriodStartDate");
     if (firstPeriodStartDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in firstPeriodStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 firstPeriodStartDateIDRef = item.Attributes["id"].Name;
                 AdjustableDate ob = AdjustableDate();
                 IDManager.SetID(firstPeriodStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 firstPeriodStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 firstPeriodStartDate = new AdjustableDate(item);
             }
         }
     }
     
 
     XmlNodeList firstRegularPeriodStartDateNodeList = xmlNode.SelectNodes("firstRegularPeriodStartDate");
     if (firstRegularPeriodStartDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in firstRegularPeriodStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 firstRegularPeriodStartDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(firstRegularPeriodStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 firstRegularPeriodStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 firstRegularPeriodStartDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList firstCompoundingPeriodEndDateNodeList = xmlNode.SelectNodes("firstCompoundingPeriodEndDate");
     if (firstCompoundingPeriodEndDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in firstCompoundingPeriodEndDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 firstCompoundingPeriodEndDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(firstCompoundingPeriodEndDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 firstCompoundingPeriodEndDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 firstCompoundingPeriodEndDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList lastRegularPeriodEndDateNodeList = xmlNode.SelectNodes("lastRegularPeriodEndDate");
     if (lastRegularPeriodEndDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in lastRegularPeriodEndDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 lastRegularPeriodEndDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(lastRegularPeriodEndDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 lastRegularPeriodEndDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 lastRegularPeriodEndDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList stubPeriodTypeNodeList = xmlNode.SelectNodes("stubPeriodType");
     if (stubPeriodTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in stubPeriodTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stubPeriodTypeIDRef = item.Attributes["id"].Name;
                 StubPeriodTypeEnum ob = StubPeriodTypeEnum();
                 IDManager.SetID(stubPeriodTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stubPeriodTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 stubPeriodType = new StubPeriodTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList calculationPeriodFrequencyNodeList = xmlNode.SelectNodes("calculationPeriodFrequency");
     if (calculationPeriodFrequencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodFrequencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodFrequencyIDRef = item.Attributes["id"].Name;
                 CalculationPeriodFrequency ob = CalculationPeriodFrequency();
                 IDManager.SetID(calculationPeriodFrequencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodFrequencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodFrequency = new CalculationPeriodFrequency(item);
             }
         }
     }
     
 
 }