public LoanParticipation(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList qualifyingParticipationSellerNodeList = xmlNode.SelectNodes("qualifyingParticipationSeller");
     if (qualifyingParticipationSellerNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in qualifyingParticipationSellerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 qualifyingParticipationSellerIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(qualifyingParticipationSellerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 qualifyingParticipationSellerIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 qualifyingParticipationSeller = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public MutualFund(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList openEndedFundNodeList = xmlNode.SelectNodes("openEndedFund");
     if (openEndedFundNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in openEndedFundNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 openEndedFundIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(openEndedFundIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 openEndedFundIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 openEndedFund = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList fundManagerNodeList = xmlNode.SelectNodes("fundManager");
     if (fundManagerNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fundManagerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fundManagerIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(fundManagerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fundManagerIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fundManager = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public StreetAddress(XmlNode xmlNode)
 {
     XmlNodeList streetLineNodeList = xmlNode.SelectNodes("streetLine");
     
     foreach (XmlNode item in streetLineNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 streetLineIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = new XsdTypeString();
                 ob.Add(new XsdTypeString(item));
                 IDManager.SetID(streetLineIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 streetLineIDRef = item.Attributes["href"].Name;
             }
             else
             {
             streetLine.Add(new XsdTypeString(item));
             }
         }
     }
     
 
 }
 public YieldCurve(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList algorithmNodeList = xmlNode.SelectNodes("algorithm");
     if (algorithmNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in algorithmNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 algorithmIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(algorithmIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 algorithmIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 algorithm = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList forecastRateIndexNodeList = xmlNode.SelectNodes("forecastRateIndex");
     if (forecastRateIndexNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in forecastRateIndexNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 forecastRateIndexIDRef = item.Attributes["id"].Name;
                 ForecastRateIndex ob = ForecastRateIndex();
                 IDManager.SetID(forecastRateIndexIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 forecastRateIndexIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 forecastRateIndex = new ForecastRateIndex(item);
             }
         }
     }
     
 
 }
 public TelephoneNumber(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;
                 TelephoneTypeEnum ob = TelephoneTypeEnum();
                 IDManager.SetID(typeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 typeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 type = new TelephoneTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList numberNodeList = xmlNode.SelectNodes("number");
     if (numberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(numberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 number = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public FormulaComponent(XmlNode xmlNode)
 {
     XmlNodeList componentDescriptionNodeList = xmlNode.SelectNodes("componentDescription");
     if (componentDescriptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in componentDescriptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 componentDescriptionIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(componentDescriptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 componentDescriptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 componentDescription = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList formulaNodeList = xmlNode.SelectNodes("formula");
     if (formulaNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in formulaNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 formulaIDRef = item.Attributes["id"].Name;
                 Formula ob = Formula();
                 IDManager.SetID(formulaIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 formulaIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 formula = new Formula(item);
             }
         }
     }
     
 
 }
 public ReferenceBank(XmlNode xmlNode)
 {
     XmlNodeList referenceBankIdNodeList = xmlNode.SelectNodes("referenceBankId");
     if (referenceBankIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in referenceBankIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 referenceBankIdIDRef = item.Attributes["id"].Name;
                 ReferenceBankId ob = ReferenceBankId();
                 IDManager.SetID(referenceBankIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 referenceBankIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 referenceBankId = new ReferenceBankId(item);
             }
         }
     }
     
 
     XmlNodeList referenceBankNameNodeList = xmlNode.SelectNodes("referenceBankName");
     if (referenceBankNameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in referenceBankNameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 referenceBankNameIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(referenceBankNameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 referenceBankNameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 referenceBankName = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public IdentifiedAsset(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList instrumentIdNodeList = xmlNode.SelectNodes("instrumentId");
     
     foreach (XmlNode item in instrumentIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 instrumentIdIDRef = item.Attributes["id"].Name;
                 List<InstrumentId> ob = new List<InstrumentId>();
                 ob.Add(new InstrumentId(item));
                 IDManager.SetID(instrumentIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 instrumentIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             instrumentId.Add(new InstrumentId(item));
             }
         }
     }
     
 
     XmlNodeList descriptionNodeList = xmlNode.SelectNodes("description");
     if (descriptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in descriptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 descriptionIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(descriptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 descriptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 description = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public ExchangeTradedContract(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList multiplierNodeList = xmlNode.SelectNodes("multiplier");
     if (multiplierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in multiplierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 multiplierIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(multiplierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 multiplierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 multiplier = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList contractReferenceNodeList = xmlNode.SelectNodes("contractReference");
     if (contractReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in contractReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 contractReferenceIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(contractReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 contractReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 contractReference = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList expirationDateNodeList = xmlNode.SelectNodes("expirationDate");
     if (expirationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in expirationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 expirationDateIDRef = item.Attributes["id"].Name;
                 AdjustableOrRelativeDate ob = AdjustableOrRelativeDate();
                 IDManager.SetID(expirationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 expirationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 expirationDate = new AdjustableOrRelativeDate(item);
             }
         }
     }
     
 
 }
예제 #10
0
 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 SensitivityDefinition(XmlNode xmlNode)
 {
     XmlNodeList nameNodeList = xmlNode.SelectNodes("name");
     if (nameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nameIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(nameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 name = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList valuationScenarioReferenceNodeList = xmlNode.SelectNodes("valuationScenarioReference");
     if (valuationScenarioReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationScenarioReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationScenarioReferenceIDRef = item.Attributes["id"].Name;
                 ValuationScenarioReference ob = ValuationScenarioReference();
                 IDManager.SetID(valuationScenarioReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationScenarioReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationScenarioReference = new ValuationScenarioReference(item);
             }
         }
     }
     
 
     XmlNodeList partialDerivativeNodeList = xmlNode.SelectNodes("partialDerivative");
     
     foreach (XmlNode item in partialDerivativeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 partialDerivativeIDRef = item.Attributes["id"].Name;
                 List<PricingParameterDerivative> ob = new List<PricingParameterDerivative>();
                 ob.Add(new PricingParameterDerivative(item));
                 IDManager.SetID(partialDerivativeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 partialDerivativeIDRef = item.Attributes["href"].Name;
             }
             else
             {
             partialDerivative.Add(new PricingParameterDerivative(item));
             }
         }
     }
     
 
     XmlNodeList formulaNodeList = xmlNode.SelectNodes("formula");
     if (formulaNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in formulaNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 formulaIDRef = item.Attributes["id"].Name;
                 DerivativeFormula ob = DerivativeFormula();
                 IDManager.SetID(formulaIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 formulaIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 formula = new DerivativeFormula(item);
             }
         }
     }
     
 
     XmlNodeList termNodeList = xmlNode.SelectNodes("term");
     if (termNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in termNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 termIDRef = item.Attributes["id"].Name;
                 TimeDimension ob = TimeDimension();
                 IDManager.SetID(termIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 termIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 term = new TimeDimension(item);
             }
         }
     }
     
 
     XmlNodeList coordinateNodeList = xmlNode.SelectNodes("coordinate");
     if (coordinateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in coordinateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 coordinateIDRef = item.Attributes["id"].Name;
                 PricingDataPointCoordinate ob = PricingDataPointCoordinate();
                 IDManager.SetID(coordinateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 coordinateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 coordinate = new PricingDataPointCoordinate(item);
             }
         }
     }
     
 
     XmlNodeList coordinateReferenceNodeList = xmlNode.SelectNodes("coordinateReference");
     if (coordinateReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in coordinateReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 coordinateReferenceIDRef = item.Attributes["id"].Name;
                 PricingDataPointCoordinateReference ob = PricingDataPointCoordinateReference();
                 IDManager.SetID(coordinateReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 coordinateReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 coordinateReference = new PricingDataPointCoordinateReference(item);
             }
         }
     }
     
 
 }
 public CashSettlementTerms(XmlNode xmlNode)
 : base(xmlNode)
 {
     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;
                 ValuationDate ob = ValuationDate();
                 IDManager.SetID(valuationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationDate = new ValuationDate(item);
             }
         }
     }
     
 
     XmlNodeList valuationTimeNodeList = xmlNode.SelectNodes("valuationTime");
     if (valuationTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationTimeIDRef = item.Attributes["id"].Name;
                 BusinessCenterTime ob = BusinessCenterTime();
                 IDManager.SetID(valuationTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationTime = new BusinessCenterTime(item);
             }
         }
     }
     
 
     XmlNodeList quotationMethodNodeList = xmlNode.SelectNodes("quotationMethod");
     if (quotationMethodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in quotationMethodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 quotationMethodIDRef = item.Attributes["id"].Name;
                 QuotationRateTypeEnum ob = QuotationRateTypeEnum();
                 IDManager.SetID(quotationMethodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 quotationMethodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 quotationMethod = new QuotationRateTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList quotationAmountNodeList = xmlNode.SelectNodes("quotationAmount");
     if (quotationAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in quotationAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 quotationAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(quotationAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 quotationAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 quotationAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList minimumQuotationAmountNodeList = xmlNode.SelectNodes("minimumQuotationAmount");
     if (minimumQuotationAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumQuotationAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumQuotationAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(minimumQuotationAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumQuotationAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimumQuotationAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList dealerNodeList = xmlNode.SelectNodes("dealer");
     
     foreach (XmlNode item in dealerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dealerIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = new XsdTypeString();
                 ob.Add(new XsdTypeString(item));
                 IDManager.SetID(dealerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dealerIDRef = item.Attributes["href"].Name;
             }
             else
             {
             dealer.Add(new XsdTypeString(item));
             }
         }
     }
     
 
     XmlNodeList cashSettlementBusinessDaysNodeList = xmlNode.SelectNodes("cashSettlementBusinessDays");
     if (cashSettlementBusinessDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cashSettlementBusinessDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cashSettlementBusinessDaysIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(cashSettlementBusinessDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cashSettlementBusinessDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cashSettlementBusinessDays = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList cashSettlementAmountNodeList = xmlNode.SelectNodes("cashSettlementAmount");
     if (cashSettlementAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cashSettlementAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cashSettlementAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(cashSettlementAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cashSettlementAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cashSettlementAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList recoveryFactorNodeList = xmlNode.SelectNodes("recoveryFactor");
     if (recoveryFactorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in recoveryFactorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 recoveryFactorIDRef = item.Attributes["id"].Name;
                 RestrictedPercentage ob = RestrictedPercentage();
                 IDManager.SetID(recoveryFactorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 recoveryFactorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 recoveryFactor = new RestrictedPercentage(item);
             }
         }
     }
     
 
     XmlNodeList fixedSettlementNodeList = xmlNode.SelectNodes("fixedSettlement");
     if (fixedSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fixedSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fixedSettlementIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(fixedSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fixedSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fixedSettlement = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList accruedInterestNodeList = xmlNode.SelectNodes("accruedInterest");
     if (accruedInterestNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in accruedInterestNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 accruedInterestIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(accruedInterestIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 accruedInterestIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 accruedInterest = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList valuationMethodNodeList = xmlNode.SelectNodes("valuationMethod");
     if (valuationMethodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationMethodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationMethodIDRef = item.Attributes["id"].Name;
                 ValuationMethodEnum ob = ValuationMethodEnum();
                 IDManager.SetID(valuationMethodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationMethodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationMethod = new ValuationMethodEnum(item);
             }
         }
     }
     
 
 }
 public CommodityInformationSource(XmlNode xmlNode)
 {
     XmlNodeList rateSourceNodeList = xmlNode.SelectNodes("rateSource");
     if (rateSourceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in rateSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 rateSourceIDRef = item.Attributes["id"].Name;
                 CommodityInformationProvider ob = CommodityInformationProvider();
                 IDManager.SetID(rateSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 rateSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 rateSource = new CommodityInformationProvider(item);
             }
         }
     }
     
 
     XmlNodeList rateSourcePageNodeList = xmlNode.SelectNodes("rateSourcePage");
     if (rateSourcePageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in rateSourcePageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 rateSourcePageIDRef = item.Attributes["id"].Name;
                 RateSourcePage ob = RateSourcePage();
                 IDManager.SetID(rateSourcePageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 rateSourcePageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 rateSourcePage = new RateSourcePage(item);
             }
         }
     }
     
 
     XmlNodeList rateSourcePageHeadingNodeList = xmlNode.SelectNodes("rateSourcePageHeading");
     if (rateSourcePageHeadingNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in rateSourcePageHeadingNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 rateSourcePageHeadingIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(rateSourcePageHeadingIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 rateSourcePageHeadingIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 rateSourcePageHeading = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public DerivativeCalculationProcedure(XmlNode xmlNode)
 {
     XmlNodeList methodNodeList = xmlNode.SelectNodes("method");
     if (methodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in methodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 methodIDRef = item.Attributes["id"].Name;
                 DerivativeCalculationMethod ob = DerivativeCalculationMethod();
                 IDManager.SetID(methodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 methodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 method = new DerivativeCalculationMethod(item);
             }
         }
     }
     
 
     XmlNodeList perturbationAmountNodeList = xmlNode.SelectNodes("perturbationAmount");
     if (perturbationAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in perturbationAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 perturbationAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(perturbationAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 perturbationAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 perturbationAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList averagedNodeList = xmlNode.SelectNodes("averaged");
     if (averagedNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in averagedNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 averagedIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(averagedIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 averagedIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 averaged = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList perturbationTypeNodeList = xmlNode.SelectNodes("perturbationType");
     if (perturbationTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in perturbationTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 perturbationTypeIDRef = item.Attributes["id"].Name;
                 PerturbationType ob = PerturbationType();
                 IDManager.SetID(perturbationTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 perturbationTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 perturbationType = new PerturbationType(item);
             }
         }
     }
     
 
     XmlNodeList derivativeFormulaNodeList = xmlNode.SelectNodes("derivativeFormula");
     if (derivativeFormulaNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in derivativeFormulaNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 derivativeFormulaIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(derivativeFormulaIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 derivativeFormulaIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 derivativeFormula = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList replacementMarketInputNodeList = xmlNode.SelectNodes("replacementMarketInput");
     if (replacementMarketInputNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in replacementMarketInputNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 replacementMarketInputIDRef = item.Attributes["id"].Name;
                 PricingStructureReference ob = PricingStructureReference();
                 IDManager.SetID(replacementMarketInputIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 replacementMarketInputIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 replacementMarketInput = new PricingStructureReference(item);
             }
         }
     }
     
 
 }
 public TradeDifference(XmlNode xmlNode)
 {
     XmlNodeList differenceTypeNodeList = xmlNode.SelectNodes("differenceType");
     if (differenceTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in differenceTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 differenceTypeIDRef = item.Attributes["id"].Name;
                 DifferenceTypeEnum ob = DifferenceTypeEnum();
                 IDManager.SetID(differenceTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 differenceTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 differenceType = new DifferenceTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList differenceSeverityNodeList = xmlNode.SelectNodes("differenceSeverity");
     if (differenceSeverityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in differenceSeverityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 differenceSeverityIDRef = item.Attributes["id"].Name;
                 DifferenceSeverityEnum ob = DifferenceSeverityEnum();
                 IDManager.SetID(differenceSeverityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 differenceSeverityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 differenceSeverity = new DifferenceSeverityEnum(item);
             }
         }
     }
     
 
     XmlNodeList elementNodeList = xmlNode.SelectNodes("element");
     if (elementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in elementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 elementIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(elementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 elementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 element = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList basePathNodeList = xmlNode.SelectNodes("basePath");
     if (basePathNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in basePathNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 basePathIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(basePathIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 basePathIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 basePath = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList baseValueNodeList = xmlNode.SelectNodes("baseValue");
     if (baseValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in baseValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 baseValueIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(baseValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 baseValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 baseValue = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList otherPathNodeList = xmlNode.SelectNodes("otherPath");
     if (otherPathNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherPathNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherPathIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(otherPathIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherPathIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherPath = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList otherValueNodeList = xmlNode.SelectNodes("otherValue");
     if (otherValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherValueIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(otherValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherValue = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList missingElementNodeList = xmlNode.SelectNodes("missingElement");
     
     foreach (XmlNode item in missingElementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 missingElementIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = new XsdTypeString();
                 ob.Add(new XsdTypeString(item));
                 IDManager.SetID(missingElementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 missingElementIDRef = item.Attributes["href"].Name;
             }
             else
             {
             missingElement.Add(new XsdTypeString(item));
             }
         }
     }
     
 
     XmlNodeList extraElementNodeList = xmlNode.SelectNodes("extraElement");
     
     foreach (XmlNode item in extraElementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 extraElementIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = new XsdTypeString();
                 ob.Add(new XsdTypeString(item));
                 IDManager.SetID(extraElementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 extraElementIDRef = item.Attributes["href"].Name;
             }
             else
             {
             extraElement.Add(new XsdTypeString(item));
             }
         }
     }
     
 
     XmlNodeList messageNodeList = xmlNode.SelectNodes("message");
     if (messageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in messageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 messageIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(messageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 messageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 message = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public BrokerEquityOption(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList deltaCrossedNodeList = xmlNode.SelectNodes("deltaCrossed");
     if (deltaCrossedNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in deltaCrossedNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 deltaCrossedIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(deltaCrossedIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 deltaCrossedIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 deltaCrossed = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList brokerageFeeNodeList = xmlNode.SelectNodes("brokerageFee");
     if (brokerageFeeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in brokerageFeeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 brokerageFeeIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(brokerageFeeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 brokerageFeeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 brokerageFee = new Money(item);
             }
         }
     }
     
 
     XmlNodeList brokerNotesNodeList = xmlNode.SelectNodes("brokerNotes");
     if (brokerNotesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in brokerNotesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 brokerNotesIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(brokerNotesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 brokerNotesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 brokerNotes = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public SensitivitySetDefinition(XmlNode xmlNode)
 {
     XmlNodeList nameNodeList = xmlNode.SelectNodes("name");
     if (nameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nameIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(nameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 name = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList sensitivityCharacteristicsNodeList = xmlNode.SelectNodes("sensitivityCharacteristics");
     if (sensitivityCharacteristicsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sensitivityCharacteristicsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sensitivityCharacteristicsIDRef = item.Attributes["id"].Name;
                 QuotationCharacteristics ob = QuotationCharacteristics();
                 IDManager.SetID(sensitivityCharacteristicsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sensitivityCharacteristicsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sensitivityCharacteristics = new QuotationCharacteristics(item);
             }
         }
     }
     
 
     XmlNodeList valuationScenarioReferenceNodeList = xmlNode.SelectNodes("valuationScenarioReference");
     if (valuationScenarioReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationScenarioReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationScenarioReferenceIDRef = item.Attributes["id"].Name;
                 ValuationScenarioReference ob = ValuationScenarioReference();
                 IDManager.SetID(valuationScenarioReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationScenarioReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationScenarioReference = new ValuationScenarioReference(item);
             }
         }
     }
     
 
     XmlNodeList pricingInputTypeNodeList = xmlNode.SelectNodes("pricingInputType");
     if (pricingInputTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in pricingInputTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pricingInputTypeIDRef = item.Attributes["id"].Name;
                 PricingInputType ob = PricingInputType();
                 IDManager.SetID(pricingInputTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pricingInputTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 pricingInputType = new PricingInputType(item);
             }
         }
     }
     
 
     XmlNodeList pricingInputReferenceNodeList = xmlNode.SelectNodes("pricingInputReference");
     if (pricingInputReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in pricingInputReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pricingInputReferenceIDRef = item.Attributes["id"].Name;
                 PricingStructureReference ob = PricingStructureReference();
                 IDManager.SetID(pricingInputReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pricingInputReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 pricingInputReference = new PricingStructureReference(item);
             }
         }
     }
     
 
     XmlNodeList scaleNodeList = xmlNode.SelectNodes("scale");
     if (scaleNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in scaleNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 scaleIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(scaleIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 scaleIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 scale = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList sensitivityDefinitionNodeList = xmlNode.SelectNodes("sensitivityDefinition");
     
     foreach (XmlNode item in sensitivityDefinitionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sensitivityDefinitionIDRef = item.Attributes["id"].Name;
                 List<SensitivityDefinition> ob = new List<SensitivityDefinition>();
                 ob.Add(new SensitivityDefinition(item));
                 IDManager.SetID(sensitivityDefinitionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sensitivityDefinitionIDRef = item.Attributes["href"].Name;
             }
             else
             {
             sensitivityDefinition.Add(new SensitivityDefinition(item));
             }
         }
     }
     
 
     XmlNodeList calculationProcedureNodeList = xmlNode.SelectNodes("calculationProcedure");
     if (calculationProcedureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationProcedureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationProcedureIDRef = item.Attributes["id"].Name;
                 DerivativeCalculationProcedure ob = DerivativeCalculationProcedure();
                 IDManager.SetID(calculationProcedureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationProcedureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationProcedure = new DerivativeCalculationProcedure(item);
             }
         }
     }
     
 
 }
 public Resource(XmlNode xmlNode)
 {
     XmlNodeList resourceIdNodeList = xmlNode.SelectNodes("resourceId");
     if (resourceIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in resourceIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 resourceIdIDRef = item.Attributes["id"].Name;
                 ResourceId ob = ResourceId();
                 IDManager.SetID(resourceIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 resourceIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 resourceId = new ResourceId(item);
             }
         }
     }
     
 
     XmlNodeList resourceTypeNodeList = xmlNode.SelectNodes("resourceType");
     if (resourceTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in resourceTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 resourceTypeIDRef = item.Attributes["id"].Name;
                 ResourceType ob = ResourceType();
                 IDManager.SetID(resourceTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 resourceTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 resourceType = new ResourceType(item);
             }
         }
     }
     
 
     XmlNodeList languageNodeList = xmlNode.SelectNodes("language");
     if (languageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in languageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 languageIDRef = item.Attributes["id"].Name;
                 Language ob = Language();
                 IDManager.SetID(languageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 languageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 language = new Language(item);
             }
         }
     }
     
 
     XmlNodeList sizeInBytesNodeList = xmlNode.SelectNodes("sizeInBytes");
     if (sizeInBytesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sizeInBytesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sizeInBytesIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(sizeInBytesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sizeInBytesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sizeInBytes = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList lengthNodeList = xmlNode.SelectNodes("length");
     if (lengthNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in lengthNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 lengthIDRef = item.Attributes["id"].Name;
                 ResourceLength ob = ResourceLength();
                 IDManager.SetID(lengthIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 lengthIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 length = new ResourceLength(item);
             }
         }
     }
     
 
     XmlNodeList mimeTypeNodeList = xmlNode.SelectNodes("mimeType");
     if (mimeTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mimeTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mimeTypeIDRef = item.Attributes["id"].Name;
                 MimeType ob = MimeType();
                 IDManager.SetID(mimeTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mimeTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mimeType = new MimeType(item);
             }
         }
     }
     
 
     XmlNodeList nameNodeList = xmlNode.SelectNodes("name");
     if (nameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nameIDRef = item.Attributes["id"].Name;
                 XsdTypeNormalizedString ob = XsdTypeNormalizedString();
                 IDManager.SetID(nameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 name = new XsdTypeNormalizedString(item);
             }
         }
     }
     
 
     XmlNodeList commentsNodeList = xmlNode.SelectNodes("comments");
     if (commentsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in commentsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 commentsIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(commentsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 commentsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 comments = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList stringNodeList = xmlNode.SelectNodes("string");
     if (stringNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in stringNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stringIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(stringIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stringIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 string = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList hexadecimalBinaryNodeList = xmlNode.SelectNodes("hexadecimalBinary");
     if (hexadecimalBinaryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in hexadecimalBinaryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 hexadecimalBinaryIDRef = item.Attributes["id"].Name;
                 XsdTypeHexBinary ob = XsdTypeHexBinary();
                 IDManager.SetID(hexadecimalBinaryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 hexadecimalBinaryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 hexadecimalBinary = new XsdTypeHexBinary(item);
             }
         }
     }
     
 
     XmlNodeList base64BinaryNodeList = xmlNode.SelectNodes("base64Binary");
     if (base64BinaryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in base64BinaryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 base64BinaryIDRef = item.Attributes["id"].Name;
                 XsdTypeBase64Binary ob = XsdTypeBase64Binary();
                 IDManager.SetID(base64BinaryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 base64BinaryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 base64Binary = new XsdTypeBase64Binary(item);
             }
         }
     }
     
 
     XmlNodeList urlNodeList = xmlNode.SelectNodes("url");
     if (urlNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in urlNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 urlIDRef = item.Attributes["id"].Name;
                 XsdTypeAnyURI ob = XsdTypeAnyURI();
                 IDManager.SetID(urlIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 urlIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 url = new XsdTypeAnyURI(item);
             }
         }
     }
     
 
 }
 public Address(XmlNode xmlNode)
 {
     XmlNodeList streetAddressNodeList = xmlNode.SelectNodes("streetAddress");
     if (streetAddressNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in streetAddressNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 streetAddressIDRef = item.Attributes["id"].Name;
                 StreetAddress ob = StreetAddress();
                 IDManager.SetID(streetAddressIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 streetAddressIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 streetAddress = new StreetAddress(item);
             }
         }
     }
     
 
     XmlNodeList cityNodeList = xmlNode.SelectNodes("city");
     if (cityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cityIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(cityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 city = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList stateNodeList = xmlNode.SelectNodes("state");
     if (stateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in stateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stateIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(stateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 state = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList countryNodeList = xmlNode.SelectNodes("country");
     if (countryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in countryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 countryIDRef = item.Attributes["id"].Name;
                 CountryCode ob = CountryCode();
                 IDManager.SetID(countryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 countryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 country = new CountryCode(item);
             }
         }
     }
     
 
     XmlNodeList postalCodeNodeList = xmlNode.SelectNodes("postalCode");
     if (postalCodeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in postalCodeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 postalCodeIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(postalCodeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 postalCodeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 postalCode = new XsdTypeString(item);
             }
         }
     }
     
 
 }
 public BusinessUnit(XmlNode xmlNode)
 {
     XmlNodeList nameNodeList = xmlNode.SelectNodes("name");
     if (nameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nameIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(nameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 name = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList businessUnitIdNodeList = xmlNode.SelectNodes("businessUnitId");
     if (businessUnitIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in businessUnitIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 businessUnitIdIDRef = item.Attributes["id"].Name;
                 Unit ob = Unit();
                 IDManager.SetID(businessUnitIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 businessUnitIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 businessUnitId = new Unit(item);
             }
         }
     }
     
 
     XmlNodeList contactInfoNodeList = xmlNode.SelectNodes("contactInfo");
     if (contactInfoNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in contactInfoNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 contactInfoIDRef = item.Attributes["id"].Name;
                 ContactInformation ob = ContactInformation();
                 IDManager.SetID(contactInfoIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 contactInfoIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 contactInfo = new ContactInformation(item);
             }
         }
     }
     
 
     XmlNodeList countryNodeList = xmlNode.SelectNodes("country");
     if (countryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in countryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 countryIDRef = item.Attributes["id"].Name;
                 CountryCode ob = CountryCode();
                 IDManager.SetID(countryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 countryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 country = new CountryCode(item);
             }
         }
     }
     
 
 }
 public DerivedValuationScenario(XmlNode xmlNode)
 {
     XmlNodeList nameNodeList = xmlNode.SelectNodes("name");
     if (nameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nameIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(nameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 name = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList baseValuationScenarioNodeList = xmlNode.SelectNodes("baseValuationScenario");
     if (baseValuationScenarioNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in baseValuationScenarioNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 baseValuationScenarioIDRef = item.Attributes["id"].Name;
                 ValuationScenarioReference ob = ValuationScenarioReference();
                 IDManager.SetID(baseValuationScenarioIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 baseValuationScenarioIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 baseValuationScenario = new ValuationScenarioReference(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;
                 IdentifiedDate ob = IdentifiedDate();
                 IDManager.SetID(valuationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationDate = new IdentifiedDate(item);
             }
         }
     }
     
 
     XmlNodeList marketReferenceNodeList = xmlNode.SelectNodes("marketReference");
     if (marketReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in marketReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 marketReferenceIDRef = item.Attributes["id"].Name;
                 MarketReference ob = MarketReference();
                 IDManager.SetID(marketReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 marketReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 marketReference = new MarketReference(item);
             }
         }
     }
     
 
     XmlNodeList shiftNodeList = xmlNode.SelectNodes("shift");
     
     foreach (XmlNode item in shiftNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 shiftIDRef = item.Attributes["id"].Name;
                 List<PricingParameterShift> ob = new List<PricingParameterShift>();
                 ob.Add(new PricingParameterShift(item));
                 IDManager.SetID(shiftIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 shiftIDRef = item.Attributes["href"].Name;
             }
             else
             {
             shift.Add(new PricingParameterShift(item));
             }
         }
     }
     
 
 }
 public FxAsianFeature(XmlNode xmlNode)
 {
     XmlNodeList primaryRateSourceNodeList = xmlNode.SelectNodes("primaryRateSource");
     if (primaryRateSourceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in primaryRateSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 primaryRateSourceIDRef = item.Attributes["id"].Name;
                 InformationSource ob = InformationSource();
                 IDManager.SetID(primaryRateSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 primaryRateSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 primaryRateSource = new InformationSource(item);
             }
         }
     }
     
 
     XmlNodeList secondaryRateSourceNodeList = xmlNode.SelectNodes("secondaryRateSource");
     if (secondaryRateSourceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in secondaryRateSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 secondaryRateSourceIDRef = item.Attributes["id"].Name;
                 InformationSource ob = InformationSource();
                 IDManager.SetID(secondaryRateSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 secondaryRateSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 secondaryRateSource = new InformationSource(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 observationScheduleNodeList = xmlNode.SelectNodes("observationSchedule");
     if (observationScheduleNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in observationScheduleNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 observationScheduleIDRef = item.Attributes["id"].Name;
                 FxAverageRateObservationSchedule ob = FxAverageRateObservationSchedule();
                 IDManager.SetID(observationScheduleIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 observationScheduleIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 observationSchedule = new FxAverageRateObservationSchedule(item);
             }
         }
     }
     
 
     XmlNodeList rateObservationNodeList = xmlNode.SelectNodes("rateObservation");
     
     foreach (XmlNode item in rateObservationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 rateObservationIDRef = item.Attributes["id"].Name;
                 List<FxAverageRateObservation> ob = new List<FxAverageRateObservation>();
                 ob.Add(new FxAverageRateObservation(item));
                 IDManager.SetID(rateObservationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 rateObservationIDRef = item.Attributes["href"].Name;
             }
             else
             {
             rateObservation.Add(new FxAverageRateObservation(item));
             }
         }
     }
     
 
     XmlNodeList rateObservationQuoteBasisNodeList = xmlNode.SelectNodes("rateObservationQuoteBasis");
     if (rateObservationQuoteBasisNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in rateObservationQuoteBasisNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 rateObservationQuoteBasisIDRef = item.Attributes["id"].Name;
                 StrikeQuoteBasisEnum ob = StrikeQuoteBasisEnum();
                 IDManager.SetID(rateObservationQuoteBasisIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 rateObservationQuoteBasisIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 rateObservationQuoteBasis = new StrikeQuoteBasisEnum(item);
             }
         }
     }
     
 
     XmlNodeList payoutFormulaNodeList = xmlNode.SelectNodes("payoutFormula");
     if (payoutFormulaNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in payoutFormulaNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 payoutFormulaIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(payoutFormulaIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 payoutFormulaIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 payoutFormula = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList precisionNodeList = xmlNode.SelectNodes("precision");
     if (precisionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in precisionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 precisionIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(precisionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 precisionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 precision = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
 }
 public Market(XmlNode xmlNode)
 {
     XmlNodeList nameNodeList = xmlNode.SelectNodes("name");
     if (nameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nameIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(nameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 name = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList benchmarkQuotesNodeList = xmlNode.SelectNodes("benchmarkQuotes");
     if (benchmarkQuotesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in benchmarkQuotesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 benchmarkQuotesIDRef = item.Attributes["id"].Name;
                 QuotedAssetSet ob = QuotedAssetSet();
                 IDManager.SetID(benchmarkQuotesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 benchmarkQuotesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 benchmarkQuotes = new QuotedAssetSet(item);
             }
         }
     }
     
 
     XmlNodeList pricingStructureNodeList = xmlNode.SelectNodes("pricingStructure");
     if (pricingStructureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in pricingStructureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pricingStructureIDRef = item.Attributes["id"].Name;
                 PricingStructure ob = PricingStructure();
                 IDManager.SetID(pricingStructureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pricingStructureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 pricingStructure = new PricingStructure(item);
             }
         }
     }
     
 
     XmlNodeList creditCurveNodeList = xmlNode.SelectNodes("creditCurve");
     if (creditCurveNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditCurveNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditCurveIDRef = item.Attributes["id"].Name;
                 CreditCurve ob = CreditCurve();
                 IDManager.SetID(creditCurveIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditCurveIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditCurve = new CreditCurve(item);
             }
         }
     }
     
 
     XmlNodeList fxCurveNodeList = xmlNode.SelectNodes("fxCurve");
     if (fxCurveNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxCurveNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxCurveIDRef = item.Attributes["id"].Name;
                 FxCurve ob = FxCurve();
                 IDManager.SetID(fxCurveIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxCurveIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxCurve = new FxCurve(item);
             }
         }
     }
     
 
     XmlNodeList volatilityRepresentationNodeList = xmlNode.SelectNodes("volatilityRepresentation");
     if (volatilityRepresentationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in volatilityRepresentationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 volatilityRepresentationIDRef = item.Attributes["id"].Name;
                 VolatilityRepresentation ob = VolatilityRepresentation();
                 IDManager.SetID(volatilityRepresentationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 volatilityRepresentationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 volatilityRepresentation = new VolatilityRepresentation(item);
             }
         }
     }
     
 
     XmlNodeList yieldCurveNodeList = xmlNode.SelectNodes("yieldCurve");
     if (yieldCurveNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in yieldCurveNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 yieldCurveIDRef = item.Attributes["id"].Name;
                 YieldCurve ob = YieldCurve();
                 IDManager.SetID(yieldCurveIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 yieldCurveIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 yieldCurve = new YieldCurve(item);
             }
         }
     }
     
 
     XmlNodeList pricingStructureValuationNodeList = xmlNode.SelectNodes("pricingStructureValuation");
     if (pricingStructureValuationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in pricingStructureValuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pricingStructureValuationIDRef = item.Attributes["id"].Name;
                 PricingStructureValuation ob = PricingStructureValuation();
                 IDManager.SetID(pricingStructureValuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pricingStructureValuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 pricingStructureValuation = new PricingStructureValuation(item);
             }
         }
     }
     
 
     XmlNodeList creditCurveValuationNodeList = xmlNode.SelectNodes("creditCurveValuation");
     if (creditCurveValuationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditCurveValuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditCurveValuationIDRef = item.Attributes["id"].Name;
                 CreditCurveValuation ob = CreditCurveValuation();
                 IDManager.SetID(creditCurveValuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditCurveValuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditCurveValuation = new CreditCurveValuation(item);
             }
         }
     }
     
 
     XmlNodeList fxCurveValuationNodeList = xmlNode.SelectNodes("fxCurveValuation");
     if (fxCurveValuationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxCurveValuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxCurveValuationIDRef = item.Attributes["id"].Name;
                 FxCurveValuation ob = FxCurveValuation();
                 IDManager.SetID(fxCurveValuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxCurveValuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxCurveValuation = new FxCurveValuation(item);
             }
         }
     }
     
 
     XmlNodeList volatilityMatrixValuationNodeList = xmlNode.SelectNodes("volatilityMatrixValuation");
     if (volatilityMatrixValuationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in volatilityMatrixValuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 volatilityMatrixValuationIDRef = item.Attributes["id"].Name;
                 VolatilityMatrix ob = VolatilityMatrix();
                 IDManager.SetID(volatilityMatrixValuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 volatilityMatrixValuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 volatilityMatrixValuation = new VolatilityMatrix(item);
             }
         }
     }
     
 
     XmlNodeList yieldCurveValuationNodeList = xmlNode.SelectNodes("yieldCurveValuation");
     if (yieldCurveValuationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in yieldCurveValuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 yieldCurveValuationIDRef = item.Attributes["id"].Name;
                 YieldCurveValuation ob = YieldCurveValuation();
                 IDManager.SetID(yieldCurveValuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 yieldCurveValuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 yieldCurveValuation = new YieldCurveValuation(item);
             }
         }
     }
     
 
     XmlNodeList benchmarkPricingMethodNodeList = xmlNode.SelectNodes("benchmarkPricingMethod");
     
     foreach (XmlNode item in benchmarkPricingMethodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 benchmarkPricingMethodIDRef = item.Attributes["id"].Name;
                 List<PricingMethod> ob = new List<PricingMethod>();
                 ob.Add(new PricingMethod(item));
                 IDManager.SetID(benchmarkPricingMethodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 benchmarkPricingMethodIDRef = item.Attributes["href"].Name;
             }
             else
             {
             benchmarkPricingMethod.Add(new PricingMethod(item));
             }
         }
     }
     
 
 }
 public Formula(XmlNode xmlNode)
 {
     XmlNodeList formulaDescriptionNodeList = xmlNode.SelectNodes("formulaDescription");
     if (formulaDescriptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in formulaDescriptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 formulaDescriptionIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(formulaDescriptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 formulaDescriptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 formulaDescription = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList mathNodeList = xmlNode.SelectNodes("math");
     if (mathNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mathNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mathIDRef = item.Attributes["id"].Name;
                 Math ob = Math();
                 IDManager.SetID(mathIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mathIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 math = new Math(item);
             }
         }
     }
     
 
     XmlNodeList formulaComponentNodeList = xmlNode.SelectNodes("formulaComponent");
     
     foreach (XmlNode item in formulaComponentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 formulaComponentIDRef = item.Attributes["id"].Name;
                 List<FormulaComponent> ob = new List<FormulaComponent>();
                 ob.Add(new FormulaComponent(item));
                 IDManager.SetID(formulaComponentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 formulaComponentIDRef = item.Attributes["href"].Name;
             }
             else
             {
             formulaComponent.Add(new FormulaComponent(item));
             }
         }
     }
     
 
 }
 public PubliclyAvailableInformation(XmlNode xmlNode)
 {
     XmlNodeList standardPublicSourcesNodeList = xmlNode.SelectNodes("standardPublicSources");
     if (standardPublicSourcesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in standardPublicSourcesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 standardPublicSourcesIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(standardPublicSourcesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 standardPublicSourcesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 standardPublicSources = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList publicSourceNodeList = xmlNode.SelectNodes("publicSource");
     
     foreach (XmlNode item in publicSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 publicSourceIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = new XsdTypeString();
                 ob.Add(new XsdTypeString(item));
                 IDManager.SetID(publicSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 publicSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
             publicSource.Add(new XsdTypeString(item));
             }
         }
     }
     
 
     XmlNodeList specifiedNumberNodeList = xmlNode.SelectNodes("specifiedNumber");
     if (specifiedNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in specifiedNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 specifiedNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(specifiedNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 specifiedNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 specifiedNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public Future(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList multiplierNodeList = xmlNode.SelectNodes("multiplier");
     if (multiplierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in multiplierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 multiplierIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(multiplierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 multiplierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 multiplier = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList futureContractReferenceNodeList = xmlNode.SelectNodes("futureContractReference");
     if (futureContractReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in futureContractReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 futureContractReferenceIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(futureContractReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 futureContractReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 futureContractReference = new XsdTypeString(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);
             }
         }
     }
     
 
 }
 public ExternalDocument(XmlNode xmlNode)
 {
     XmlNodeList mimeTypeNodeList = xmlNode.SelectNodes("mimeType");
     if (mimeTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mimeTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mimeTypeIDRef = item.Attributes["id"].Name;
                 MimeType ob = MimeType();
                 IDManager.SetID(mimeTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mimeTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mimeType = new MimeType(item);
             }
         }
     }
     
 
     XmlNodeList stringNodeList = xmlNode.SelectNodes("string");
     if (stringNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in stringNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stringIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(stringIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stringIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 string = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList hexadecimalBinaryNodeList = xmlNode.SelectNodes("hexadecimalBinary");
     if (hexadecimalBinaryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in hexadecimalBinaryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 hexadecimalBinaryIDRef = item.Attributes["id"].Name;
                 XsdTypeHexBinary ob = XsdTypeHexBinary();
                 IDManager.SetID(hexadecimalBinaryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 hexadecimalBinaryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 hexadecimalBinary = new XsdTypeHexBinary(item);
             }
         }
     }
     
 
     XmlNodeList base64BinaryNodeList = xmlNode.SelectNodes("base64Binary");
     if (base64BinaryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in base64BinaryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 base64BinaryIDRef = item.Attributes["id"].Name;
                 XsdTypeBase64Binary ob = XsdTypeBase64Binary();
                 IDManager.SetID(base64BinaryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 base64BinaryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 base64Binary = new XsdTypeBase64Binary(item);
             }
         }
     }
     
 
     XmlNodeList urlNodeList = xmlNode.SelectNodes("url");
     if (urlNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in urlNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 urlIDRef = item.Attributes["id"].Name;
                 XsdTypeAnyURI ob = XsdTypeAnyURI();
                 IDManager.SetID(urlIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 urlIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 url = new XsdTypeAnyURI(item);
             }
         }
     }
     
 
     XmlNodeList attachmentReferenceNodeList = xmlNode.SelectNodes("attachmentReference");
     if (attachmentReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in attachmentReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 attachmentReferenceIDRef = item.Attributes["id"].Name;
                 HTTPAttachmentReference ob = HTTPAttachmentReference();
                 IDManager.SetID(attachmentReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 attachmentReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 attachmentReference = new HTTPAttachmentReference(item);
             }
         }
     }
     
 
 }
 public SensitivitySet(XmlNode xmlNode)
 {
     XmlNodeList nameNodeList = xmlNode.SelectNodes("name");
     if (nameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nameIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(nameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 name = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList definitionReferenceNodeList = xmlNode.SelectNodes("definitionReference");
     if (definitionReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in definitionReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 definitionReferenceIDRef = item.Attributes["id"].Name;
                 SensitivitySetDefinitionReference ob = SensitivitySetDefinitionReference();
                 IDManager.SetID(definitionReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 definitionReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 definitionReference = new SensitivitySetDefinitionReference(item);
             }
         }
     }
     
 
     XmlNodeList sensitivityNodeList = xmlNode.SelectNodes("sensitivity");
     
     foreach (XmlNode item in sensitivityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sensitivityIDRef = item.Attributes["id"].Name;
                 List<Sensitivity> ob = new List<Sensitivity>();
                 ob.Add(new Sensitivity(item));
                 IDManager.SetID(sensitivityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sensitivityIDRef = item.Attributes["href"].Name;
             }
             else
             {
             sensitivity.Add(new Sensitivity(item));
             }
         }
     }
     
 
 }
 public Reason(XmlNode xmlNode)
 {
     XmlNodeList reasonCodeNodeList = xmlNode.SelectNodes("reasonCode");
     if (reasonCodeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in reasonCodeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 reasonCodeIDRef = item.Attributes["id"].Name;
                 ReasonCode ob = ReasonCode();
                 IDManager.SetID(reasonCodeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 reasonCodeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 reasonCode = new ReasonCode(item);
             }
         }
     }
     
 
     XmlNodeList locationNodeList = xmlNode.SelectNodes("location");
     if (locationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in locationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 locationIDRef = item.Attributes["id"].Name;
                 ProblemLocation ob = ProblemLocation();
                 IDManager.SetID(locationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 locationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 location = new ProblemLocation(item);
             }
         }
     }
     
 
     XmlNodeList descriptionNodeList = xmlNode.SelectNodes("description");
     if (descriptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in descriptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 descriptionIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(descriptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 descriptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 description = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList validationRuleIdNodeList = xmlNode.SelectNodes("validationRuleId");
     if (validationRuleIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in validationRuleIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 validationRuleIdIDRef = item.Attributes["id"].Name;
                 Validation ob = Validation();
                 IDManager.SetID(validationRuleIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 validationRuleIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 validationRuleId = new Validation(item);
             }
         }
     }
     
 
     XmlNodeList additionalDataNodeList = xmlNode.SelectNodes("additionalData");
     
     foreach (XmlNode item in additionalDataNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 additionalDataIDRef = item.Attributes["id"].Name;
                 List<AdditionalData> ob = new List<AdditionalData>();
                 ob.Add(new AdditionalData(item));
                 IDManager.SetID(additionalDataIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 additionalDataIDRef = item.Attributes["href"].Name;
             }
             else
             {
             additionalData.Add(new AdditionalData(item));
             }
         }
     }
     
 
 }
 public AdditionalData(XmlNode xmlNode)
 {
     XmlNodeList mimeTypeNodeList = xmlNode.SelectNodes("mimeType");
     if (mimeTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mimeTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mimeTypeIDRef = item.Attributes["id"].Name;
                 MimeType ob = MimeType();
                 IDManager.SetID(mimeTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mimeTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mimeType = new MimeType(item);
             }
         }
     }
     
 
     XmlNodeList stringNodeList = xmlNode.SelectNodes("string");
     if (stringNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in stringNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stringIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(stringIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stringIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 string = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList hexadecimalBinaryNodeList = xmlNode.SelectNodes("hexadecimalBinary");
     if (hexadecimalBinaryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in hexadecimalBinaryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 hexadecimalBinaryIDRef = item.Attributes["id"].Name;
                 XsdTypeHexBinary ob = XsdTypeHexBinary();
                 IDManager.SetID(hexadecimalBinaryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 hexadecimalBinaryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 hexadecimalBinary = new XsdTypeHexBinary(item);
             }
         }
     }
     
 
     XmlNodeList base64BinaryNodeList = xmlNode.SelectNodes("base64Binary");
     if (base64BinaryNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in base64BinaryNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 base64BinaryIDRef = item.Attributes["id"].Name;
                 XsdTypeBase64Binary ob = XsdTypeBase64Binary();
                 IDManager.SetID(base64BinaryIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 base64BinaryIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 base64Binary = new XsdTypeBase64Binary(item);
             }
         }
     }
     
 
     XmlNodeList originalMessageNodeList = xmlNode.SelectNodes("originalMessage");
     if (originalMessageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in originalMessageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 originalMessageIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(originalMessageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 originalMessageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 originalMessage = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }