public NonNegativeStep(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList stepValueNodeList = xmlNode.SelectNodes("stepValue");
     if (stepValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in stepValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stepValueIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(stepValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stepValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 stepValue = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public NonNegativeMoney(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList amountNodeList = xmlNode.SelectNodes("amount");
     if (amountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in amountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 amountIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(amountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 amountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 amount = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public UnitQuantity(XmlNode xmlNode)
 {
     XmlNodeList quantityUnitNodeList = xmlNode.SelectNodes("quantityUnit");
     if (quantityUnitNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in quantityUnitNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 quantityUnitIDRef = item.Attributes["id"].Name;
                 QuantityUnit ob = QuantityUnit();
                 IDManager.SetID(quantityUnitIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 quantityUnitIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 quantityUnit = new QuantityUnit(item);
             }
         }
     }
     
 
     XmlNodeList quantityNodeList = xmlNode.SelectNodes("quantity");
     if (quantityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in quantityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 quantityIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(quantityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 quantityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 quantity = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public NonNegativeSchedule(XmlNode xmlNode)
 {
     XmlNodeList initialValueNodeList = xmlNode.SelectNodes("initialValue");
     if (initialValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in initialValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 initialValueIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(initialValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 initialValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 initialValue = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList stepNodeList = xmlNode.SelectNodes("step");
     
     foreach (XmlNode item in stepNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stepIDRef = item.Attributes["id"].Name;
                 List<NonNegativeStep> ob = new List<NonNegativeStep>();
                 ob.Add(new NonNegativeStep(item));
                 IDManager.SetID(stepIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stepIDRef = item.Attributes["href"].Name;
             }
             else
             {
             step.Add(new NonNegativeStep(item));
             }
         }
     }
     
 
 }
 public EquityMultipleExercise(XmlNode xmlNode)
 {
     XmlNodeList integralMultipleExerciseNodeList = xmlNode.SelectNodes("integralMultipleExercise");
     if (integralMultipleExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in integralMultipleExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 integralMultipleExerciseIDRef = item.Attributes["id"].Name;
                 PositiveDecimal ob = PositiveDecimal();
                 IDManager.SetID(integralMultipleExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 integralMultipleExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 integralMultipleExercise = new PositiveDecimal(item);
             }
         }
     }
     
 
     XmlNodeList minimumNumberOfOptionsNodeList = xmlNode.SelectNodes("minimumNumberOfOptions");
     if (minimumNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(minimumNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimumNumberOfOptions = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList maximumNumberOfOptionsNodeList = xmlNode.SelectNodes("maximumNumberOfOptions");
     if (maximumNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(maximumNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumNumberOfOptions = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public EquityPremium(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 premiumTypeNodeList = xmlNode.SelectNodes("premiumType");
     if (premiumTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in premiumTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 premiumTypeIDRef = item.Attributes["id"].Name;
                 PremiumTypeEnum ob = PremiumTypeEnum();
                 IDManager.SetID(premiumTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 premiumTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 premiumType = new PremiumTypeEnum(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;
                 NonNegativeMoney ob = NonNegativeMoney();
                 IDManager.SetID(paymentAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentAmount = new NonNegativeMoney(item);
             }
         }
     }
     
 
     XmlNodeList paymentDateNodeList = xmlNode.SelectNodes("paymentDate");
     if (paymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentDateIDRef = item.Attributes["id"].Name;
                 AdjustableDate ob = AdjustableDate();
                 IDManager.SetID(paymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentDate = new AdjustableDate(item);
             }
         }
     }
     
 
     XmlNodeList swapPremiumNodeList = xmlNode.SelectNodes("swapPremium");
     if (swapPremiumNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in swapPremiumNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 swapPremiumIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(swapPremiumIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 swapPremiumIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 swapPremium = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList pricePerOptionNodeList = xmlNode.SelectNodes("pricePerOption");
     if (pricePerOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in pricePerOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pricePerOptionIDRef = item.Attributes["id"].Name;
                 NonNegativeMoney ob = NonNegativeMoney();
                 IDManager.SetID(pricePerOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pricePerOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 pricePerOption = new NonNegativeMoney(item);
             }
         }
     }
     
 
     XmlNodeList percentageOfNotionalNodeList = xmlNode.SelectNodes("percentageOfNotional");
     if (percentageOfNotionalNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in percentageOfNotionalNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 percentageOfNotionalIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(percentageOfNotionalIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 percentageOfNotionalIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 percentageOfNotional = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public WeightedAveragingObservation(XmlNode xmlNode)
 {
     XmlNodeList dateTimeNodeList = xmlNode.SelectNodes("dateTime");
     if (dateTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dateTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dateTimeIDRef = item.Attributes["id"].Name;
                 XsdTypeDateTime ob = XsdTypeDateTime();
                 IDManager.SetID(dateTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dateTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dateTime = new XsdTypeDateTime(item);
             }
         }
     }
     
 
     XmlNodeList observationNumberNodeList = xmlNode.SelectNodes("observationNumber");
     if (observationNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in observationNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 observationNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(observationNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 observationNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 observationNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList weightNodeList = xmlNode.SelectNodes("weight");
     if (weightNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in weightNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 weightIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(weightIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 weightIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 weight = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public EquitySwapTransactionSupplement(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList mutualEarlyTerminationNodeList = xmlNode.SelectNodes("mutualEarlyTermination");
     if (mutualEarlyTerminationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mutualEarlyTerminationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mutualEarlyTerminationIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(mutualEarlyTerminationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mutualEarlyTerminationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mutualEarlyTermination = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList optionalEarlyTerminationNodeList = xmlNode.SelectNodes("optionalEarlyTermination");
     if (optionalEarlyTerminationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in optionalEarlyTerminationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 optionalEarlyTerminationIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(optionalEarlyTerminationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 optionalEarlyTerminationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 optionalEarlyTermination = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList breakFundingRecoveryNodeList = xmlNode.SelectNodes("breakFundingRecovery");
     if (breakFundingRecoveryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in breakFundingRecoveryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 breakFundingRecoveryIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(breakFundingRecoveryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 breakFundingRecoveryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 breakFundingRecovery = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList breakFeeElectionNodeList = xmlNode.SelectNodes("breakFeeElection");
     if (breakFeeElectionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in breakFeeElectionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 breakFeeElectionIDRef = item.Attributes["id"].Name;
                 FeeElectionEnum ob = FeeElectionEnum();
                 IDManager.SetID(breakFeeElectionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 breakFeeElectionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 breakFeeElection = new FeeElectionEnum(item);
             }
         }
     }
     
 
     XmlNodeList breakFeeRateNodeList = xmlNode.SelectNodes("breakFeeRate");
     if (breakFeeRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in breakFeeRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 breakFeeRateIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(breakFeeRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 breakFeeRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 breakFeeRate = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList multipleExchangeIndexAnnexFallbackNodeList = xmlNode.SelectNodes("multipleExchangeIndexAnnexFallback");
     if (multipleExchangeIndexAnnexFallbackNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in multipleExchangeIndexAnnexFallbackNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 multipleExchangeIndexAnnexFallbackIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(multipleExchangeIndexAnnexFallbackIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 multipleExchangeIndexAnnexFallbackIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 multipleExchangeIndexAnnexFallback = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList componentSecurityIndexAnnexFallbackNodeList = xmlNode.SelectNodes("componentSecurityIndexAnnexFallback");
     if (componentSecurityIndexAnnexFallbackNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in componentSecurityIndexAnnexFallbackNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 componentSecurityIndexAnnexFallbackIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(componentSecurityIndexAnnexFallbackIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 componentSecurityIndexAnnexFallbackIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 componentSecurityIndexAnnexFallback = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList localJurisdictionNodeList = xmlNode.SelectNodes("localJurisdiction");
     if (localJurisdictionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in localJurisdictionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 localJurisdictionIDRef = item.Attributes["id"].Name;
                 CountryCode ob = CountryCode();
                 IDManager.SetID(localJurisdictionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 localJurisdictionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 localJurisdiction = new CountryCode(item);
             }
         }
     }
     
 
     XmlNodeList relevantJurisdictionNodeList = xmlNode.SelectNodes("relevantJurisdiction");
     if (relevantJurisdictionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in relevantJurisdictionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 relevantJurisdictionIDRef = item.Attributes["id"].Name;
                 CountryCode ob = CountryCode();
                 IDManager.SetID(relevantJurisdictionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 relevantJurisdictionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 relevantJurisdiction = new CountryCode(item);
             }
         }
     }
     
 
     XmlNodeList extraordinaryEventsNodeList = xmlNode.SelectNodes("extraordinaryEvents");
     if (extraordinaryEventsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in extraordinaryEventsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 extraordinaryEventsIDRef = item.Attributes["id"].Name;
                 ExtraordinaryEvents ob = ExtraordinaryEvents();
                 IDManager.SetID(extraordinaryEventsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 extraordinaryEventsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 extraordinaryEvents = new ExtraordinaryEvents(item);
             }
         }
     }
     
 
 }
 public EquityDerivativeShortFormBase(XmlNode xmlNode)
 : base(xmlNode)
 {
     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;
                 EquityStrike ob = EquityStrike();
                 IDManager.SetID(strikeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 strikeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 strike = new EquityStrike(item);
             }
         }
     }
     
 
     XmlNodeList spotPriceNodeList = xmlNode.SelectNodes("spotPrice");
     if (spotPriceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in spotPriceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 spotPriceIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(spotPriceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 spotPriceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 spotPrice = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList numberOfOptionsNodeList = xmlNode.SelectNodes("numberOfOptions");
     if (numberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberOfOptionsIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(numberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 numberOfOptions = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList equityPremiumNodeList = xmlNode.SelectNodes("equityPremium");
     if (equityPremiumNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityPremiumNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityPremiumIDRef = item.Attributes["id"].Name;
                 EquityPremium ob = EquityPremium();
                 IDManager.SetID(equityPremiumIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityPremiumIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityPremium = new EquityPremium(item);
             }
         }
     }
     
 
 }
 public DividendLeg(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList declaredCashDividendPercentageNodeList = xmlNode.SelectNodes("declaredCashDividendPercentage");
     if (declaredCashDividendPercentageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in declaredCashDividendPercentageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 declaredCashDividendPercentageIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(declaredCashDividendPercentageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 declaredCashDividendPercentageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 declaredCashDividendPercentage = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList declaredCashEquivalentDividendPercentageNodeList = xmlNode.SelectNodes("declaredCashEquivalentDividendPercentage");
     if (declaredCashEquivalentDividendPercentageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in declaredCashEquivalentDividendPercentageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 declaredCashEquivalentDividendPercentageIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(declaredCashEquivalentDividendPercentageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 declaredCashEquivalentDividendPercentageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 declaredCashEquivalentDividendPercentage = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList dividendPeriodNodeList = xmlNode.SelectNodes("dividendPeriod");
     
     foreach (XmlNode item in dividendPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendPeriodIDRef = item.Attributes["id"].Name;
                 List<DividendPeriodPayment> ob = new List<DividendPeriodPayment>();
                 ob.Add(new DividendPeriodPayment(item));
                 IDManager.SetID(dividendPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
             dividendPeriod.Add(new DividendPeriodPayment(item));
             }
         }
     }
     
 
     XmlNodeList specialDividendsNodeList = xmlNode.SelectNodes("specialDividends");
     if (specialDividendsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in specialDividendsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 specialDividendsIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(specialDividendsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 specialDividendsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 specialDividends = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList materialDividendNodeList = xmlNode.SelectNodes("materialDividend");
     if (materialDividendNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in materialDividendNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 materialDividendIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(materialDividendIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 materialDividendIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 materialDividend = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public Variance(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList varianceAmountNodeList = xmlNode.SelectNodes("varianceAmount");
     if (varianceAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in varianceAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 varianceAmountIDRef = item.Attributes["id"].Name;
                 NonNegativeMoney ob = NonNegativeMoney();
                 IDManager.SetID(varianceAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 varianceAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 varianceAmount = new NonNegativeMoney(item);
             }
         }
     }
     
 
     XmlNodeList volatilityStrikePriceNodeList = xmlNode.SelectNodes("volatilityStrikePrice");
     if (volatilityStrikePriceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in volatilityStrikePriceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 volatilityStrikePriceIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(volatilityStrikePriceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 volatilityStrikePriceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 volatilityStrikePrice = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList varianceStrikePriceNodeList = xmlNode.SelectNodes("varianceStrikePrice");
     if (varianceStrikePriceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in varianceStrikePriceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 varianceStrikePriceIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(varianceStrikePriceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 varianceStrikePriceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 varianceStrikePrice = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList varianceCapNodeList = xmlNode.SelectNodes("varianceCap");
     if (varianceCapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in varianceCapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 varianceCapIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(varianceCapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 varianceCapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 varianceCap = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList unadjustedVarianceCapNodeList = xmlNode.SelectNodes("unadjustedVarianceCap");
     if (unadjustedVarianceCapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in unadjustedVarianceCapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 unadjustedVarianceCapIDRef = item.Attributes["id"].Name;
                 PositiveDecimal ob = PositiveDecimal();
                 IDManager.SetID(unadjustedVarianceCapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 unadjustedVarianceCapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 unadjustedVarianceCap = new PositiveDecimal(item);
             }
         }
     }
     
 
     XmlNodeList boundedVarianceNodeList = xmlNode.SelectNodes("boundedVariance");
     if (boundedVarianceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in boundedVarianceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 boundedVarianceIDRef = item.Attributes["id"].Name;
                 BoundedVariance ob = BoundedVariance();
                 IDManager.SetID(boundedVarianceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 boundedVarianceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 boundedVariance = new BoundedVariance(item);
             }
         }
     }
     
 
     XmlNodeList exchangeTradedContractNearestNodeList = xmlNode.SelectNodes("exchangeTradedContractNearest");
     if (exchangeTradedContractNearestNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangeTradedContractNearestNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangeTradedContractNearestIDRef = item.Attributes["id"].Name;
                 ExchangeTradedContract ob = ExchangeTradedContract();
                 IDManager.SetID(exchangeTradedContractNearestIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangeTradedContractNearestIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangeTradedContractNearest = new ExchangeTradedContract(item);
             }
         }
     }
     
 
     XmlNodeList vegaNotionalAmountNodeList = xmlNode.SelectNodes("vegaNotionalAmount");
     if (vegaNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in vegaNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 vegaNotionalAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(vegaNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 vegaNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 vegaNotionalAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
 }
 public FeaturePayment(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 levelPercentageNodeList = xmlNode.SelectNodes("levelPercentage");
     if (levelPercentageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in levelPercentageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 levelPercentageIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(levelPercentageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 levelPercentageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 levelPercentage = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList amountNodeList = xmlNode.SelectNodes("amount");
     if (amountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in amountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 amountIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(amountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 amountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 amount = new NonNegativeDecimal(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;
                 TimeTypeEnum ob = TimeTypeEnum();
                 IDManager.SetID(timeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 timeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 time = new TimeTypeEnum(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 featurePaymentDateNodeList = xmlNode.SelectNodes("featurePaymentDate");
     if (featurePaymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in featurePaymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 featurePaymentDateIDRef = item.Attributes["id"].Name;
                 AdjustableOrRelativeDate ob = AdjustableOrRelativeDate();
                 IDManager.SetID(featurePaymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 featurePaymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 featurePaymentDate = new AdjustableOrRelativeDate(item);
             }
         }
     }
     
 
 }
 public FxAverageRateObservation(XmlNode xmlNode)
 {
     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 averageRateWeightingFactorNodeList = xmlNode.SelectNodes("averageRateWeightingFactor");
     if (averageRateWeightingFactorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in averageRateWeightingFactorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 averageRateWeightingFactorIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(averageRateWeightingFactorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 averageRateWeightingFactorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 averageRateWeightingFactor = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList rateNodeList = xmlNode.SelectNodes("rate");
     if (rateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in rateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 rateIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(rateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 rateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 rate = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public GasProduct(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;
                 GasProductTypeEnum ob = GasProductTypeEnum();
                 IDManager.SetID(typeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 typeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 type = new GasProductTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList calorificValueNodeList = xmlNode.SelectNodes("calorificValue");
     if (calorificValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calorificValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calorificValueIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(calorificValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calorificValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calorificValue = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList qualityNodeList = xmlNode.SelectNodes("quality");
     if (qualityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in qualityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 qualityIDRef = item.Attributes["id"].Name;
                 GasQuality ob = GasQuality();
                 IDManager.SetID(qualityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 qualityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 quality = new GasQuality(item);
             }
         }
     }
     
 
 }
 public MultipleExercise(XmlNode xmlNode)
 {
     XmlNodeList notionalReferenceNodeList = xmlNode.SelectNodes("notionalReference");
     
     foreach (XmlNode item in notionalReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notionalReferenceIDRef = item.Attributes["id"].Name;
                 List<NotionalReference> ob = new List<NotionalReference>();
                 ob.Add(new NotionalReference(item));
                 IDManager.SetID(notionalReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
             notionalReference.Add(new NotionalReference(item));
             }
         }
     }
     
 
     XmlNodeList integralMultipleAmountNodeList = xmlNode.SelectNodes("integralMultipleAmount");
     if (integralMultipleAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in integralMultipleAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 integralMultipleAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(integralMultipleAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 integralMultipleAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 integralMultipleAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList minimumNotionalAmountNodeList = xmlNode.SelectNodes("minimumNotionalAmount");
     if (minimumNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumNotionalAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(minimumNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimumNotionalAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList minimumNumberOfOptionsNodeList = xmlNode.SelectNodes("minimumNumberOfOptions");
     if (minimumNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(minimumNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimumNumberOfOptions = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList maximumNotionalAmountNodeList = xmlNode.SelectNodes("maximumNotionalAmount");
     if (maximumNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumNotionalAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(maximumNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumNotionalAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList maximumNumberOfOptionsNodeList = xmlNode.SelectNodes("maximumNumberOfOptions");
     if (maximumNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(maximumNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumNumberOfOptions = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public BoundedVariance(XmlNode xmlNode)
 {
     XmlNodeList realisedVarianceMethodNodeList = xmlNode.SelectNodes("realisedVarianceMethod");
     if (realisedVarianceMethodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in realisedVarianceMethodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 realisedVarianceMethodIDRef = item.Attributes["id"].Name;
                 RealisedVarianceMethodEnum ob = RealisedVarianceMethodEnum();
                 IDManager.SetID(realisedVarianceMethodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 realisedVarianceMethodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 realisedVarianceMethod = new RealisedVarianceMethodEnum(item);
             }
         }
     }
     
 
     XmlNodeList daysInRangeAdjustmentNodeList = xmlNode.SelectNodes("daysInRangeAdjustment");
     if (daysInRangeAdjustmentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in daysInRangeAdjustmentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 daysInRangeAdjustmentIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(daysInRangeAdjustmentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 daysInRangeAdjustmentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 daysInRangeAdjustment = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList upperBarrierNodeList = xmlNode.SelectNodes("upperBarrier");
     if (upperBarrierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in upperBarrierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 upperBarrierIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(upperBarrierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 upperBarrierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 upperBarrier = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList lowerBarrierNodeList = xmlNode.SelectNodes("lowerBarrier");
     if (lowerBarrierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in lowerBarrierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 lowerBarrierIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(lowerBarrierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 lowerBarrierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 lowerBarrier = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public DividendConditions(XmlNode xmlNode)
 {
     XmlNodeList dividendReinvestmentNodeList = xmlNode.SelectNodes("dividendReinvestment");
     if (dividendReinvestmentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendReinvestmentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendReinvestmentIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(dividendReinvestmentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendReinvestmentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendReinvestment = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList dividendEntitlementNodeList = xmlNode.SelectNodes("dividendEntitlement");
     if (dividendEntitlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendEntitlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendEntitlementIDRef = item.Attributes["id"].Name;
                 DividendEntitlementEnum ob = DividendEntitlementEnum();
                 IDManager.SetID(dividendEntitlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendEntitlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendEntitlement = new DividendEntitlementEnum(item);
             }
         }
     }
     
 
     XmlNodeList dividendAmountNodeList = xmlNode.SelectNodes("dividendAmount");
     if (dividendAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendAmountIDRef = item.Attributes["id"].Name;
                 DividendAmountTypeEnum ob = DividendAmountTypeEnum();
                 IDManager.SetID(dividendAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendAmount = new DividendAmountTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList dividendPaymentDateNodeList = xmlNode.SelectNodes("dividendPaymentDate");
     if (dividendPaymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendPaymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendPaymentDateIDRef = item.Attributes["id"].Name;
                 DividendPaymentDate ob = DividendPaymentDate();
                 IDManager.SetID(dividendPaymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendPaymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendPaymentDate = new DividendPaymentDate(item);
             }
         }
     }
     
 
     XmlNodeList dividendPeriodEffectiveDateNodeList = xmlNode.SelectNodes("dividendPeriodEffectiveDate");
     if (dividendPeriodEffectiveDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendPeriodEffectiveDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendPeriodEffectiveDateIDRef = item.Attributes["id"].Name;
                 DateReference ob = DateReference();
                 IDManager.SetID(dividendPeriodEffectiveDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendPeriodEffectiveDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendPeriodEffectiveDate = new DateReference(item);
             }
         }
     }
     
 
     XmlNodeList dividendPeriodEndDateNodeList = xmlNode.SelectNodes("dividendPeriodEndDate");
     if (dividendPeriodEndDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendPeriodEndDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendPeriodEndDateIDRef = item.Attributes["id"].Name;
                 DateReference ob = DateReference();
                 IDManager.SetID(dividendPeriodEndDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendPeriodEndDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendPeriodEndDate = new DateReference(item);
             }
         }
     }
     
 
     XmlNodeList dividendPeriodNodeList = xmlNode.SelectNodes("dividendPeriod");
     if (dividendPeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendPeriodIDRef = item.Attributes["id"].Name;
                 DividendPeriodEnum ob = DividendPeriodEnum();
                 IDManager.SetID(dividendPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendPeriod = new DividendPeriodEnum(item);
             }
         }
     }
     
 
     XmlNodeList extraOrdinaryDividendsNodeList = xmlNode.SelectNodes("extraOrdinaryDividends");
     if (extraOrdinaryDividendsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in extraOrdinaryDividendsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 extraOrdinaryDividendsIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(extraOrdinaryDividendsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 extraOrdinaryDividendsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 extraOrdinaryDividends = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList excessDividendAmountNodeList = xmlNode.SelectNodes("excessDividendAmount");
     if (excessDividendAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in excessDividendAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 excessDividendAmountIDRef = item.Attributes["id"].Name;
                 DividendAmountTypeEnum ob = DividendAmountTypeEnum();
                 IDManager.SetID(excessDividendAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 excessDividendAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 excessDividendAmount = new DividendAmountTypeEnum(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;
                 IdentifiedCurrency ob = IdentifiedCurrency();
                 IDManager.SetID(currencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currency = new IdentifiedCurrency(item);
             }
         }
     }
     
 
     XmlNodeList determinationMethodNodeList = xmlNode.SelectNodes("determinationMethod");
     if (determinationMethodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in determinationMethodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 determinationMethodIDRef = item.Attributes["id"].Name;
                 DeterminationMethod ob = DeterminationMethod();
                 IDManager.SetID(determinationMethodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 determinationMethodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 determinationMethod = new DeterminationMethod(item);
             }
         }
     }
     
 
     XmlNodeList currencyReferenceNodeList = xmlNode.SelectNodes("currencyReference");
     if (currencyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currencyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currencyReferenceIDRef = item.Attributes["id"].Name;
                 IdentifiedCurrencyReference ob = IdentifiedCurrencyReference();
                 IDManager.SetID(currencyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currencyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currencyReference = new IdentifiedCurrencyReference(item);
             }
         }
     }
     
 
     XmlNodeList dividendFxTriggerDateNodeList = xmlNode.SelectNodes("dividendFxTriggerDate");
     if (dividendFxTriggerDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendFxTriggerDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendFxTriggerDateIDRef = item.Attributes["id"].Name;
                 DividendPaymentDate ob = DividendPaymentDate();
                 IDManager.SetID(dividendFxTriggerDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendFxTriggerDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendFxTriggerDate = new DividendPaymentDate(item);
             }
         }
     }
     
 
     XmlNodeList interestAccrualsMethodNodeList = xmlNode.SelectNodes("interestAccrualsMethod");
     if (interestAccrualsMethodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in interestAccrualsMethodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 interestAccrualsMethodIDRef = item.Attributes["id"].Name;
                 InterestAccrualsCompoundingMethod ob = InterestAccrualsCompoundingMethod();
                 IDManager.SetID(interestAccrualsMethodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 interestAccrualsMethodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 interestAccrualsMethod = new InterestAccrualsCompoundingMethod(item);
             }
         }
     }
     
 
     XmlNodeList numberOfIndexUnitsNodeList = xmlNode.SelectNodes("numberOfIndexUnits");
     if (numberOfIndexUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberOfIndexUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberOfIndexUnitsIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(numberOfIndexUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberOfIndexUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 numberOfIndexUnits = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList declaredCashDividendPercentageNodeList = xmlNode.SelectNodes("declaredCashDividendPercentage");
     if (declaredCashDividendPercentageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in declaredCashDividendPercentageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 declaredCashDividendPercentageIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(declaredCashDividendPercentageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 declaredCashDividendPercentageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 declaredCashDividendPercentage = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList declaredCashEquivalentDividendPercentageNodeList = xmlNode.SelectNodes("declaredCashEquivalentDividendPercentage");
     if (declaredCashEquivalentDividendPercentageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in declaredCashEquivalentDividendPercentageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 declaredCashEquivalentDividendPercentageIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(declaredCashEquivalentDividendPercentageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 declaredCashEquivalentDividendPercentageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 declaredCashEquivalentDividendPercentage = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList nonCashDividendTreatmentNodeList = xmlNode.SelectNodes("nonCashDividendTreatment");
     if (nonCashDividendTreatmentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nonCashDividendTreatmentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nonCashDividendTreatmentIDRef = item.Attributes["id"].Name;
                 NonCashDividendTreatmentEnum ob = NonCashDividendTreatmentEnum();
                 IDManager.SetID(nonCashDividendTreatmentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nonCashDividendTreatmentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 nonCashDividendTreatment = new NonCashDividendTreatmentEnum(item);
             }
         }
     }
     
 
     XmlNodeList dividendCompositionNodeList = xmlNode.SelectNodes("dividendComposition");
     if (dividendCompositionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendCompositionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendCompositionIDRef = item.Attributes["id"].Name;
                 DividendCompositionEnum ob = DividendCompositionEnum();
                 IDManager.SetID(dividendCompositionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendCompositionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendComposition = new DividendCompositionEnum(item);
             }
         }
     }
     
 
     XmlNodeList specialDividendsNodeList = xmlNode.SelectNodes("specialDividends");
     if (specialDividendsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in specialDividendsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 specialDividendsIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(specialDividendsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 specialDividendsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 specialDividends = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }