public SingleValuationDate(XmlNode xmlNode)
 {
     XmlNodeList businessDaysNodeList = xmlNode.SelectNodes("businessDays");
     if (businessDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in businessDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 businessDaysIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(businessDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 businessDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 businessDays = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
 }
 public Rounding(XmlNode xmlNode)
 {
     XmlNodeList roundingDirectionNodeList = xmlNode.SelectNodes("roundingDirection");
     if (roundingDirectionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in roundingDirectionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 roundingDirectionIDRef = item.Attributes["id"].Name;
                 RoundingDirectionEnum ob = RoundingDirectionEnum();
                 IDManager.SetID(roundingDirectionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 roundingDirectionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 roundingDirection = new RoundingDirectionEnum(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 AverageDailyTradingVolumeLimit(XmlNode xmlNode)
 {
     XmlNodeList limitationPercentageNodeList = xmlNode.SelectNodes("limitationPercentage");
     if (limitationPercentageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in limitationPercentageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 limitationPercentageIDRef = item.Attributes["id"].Name;
                 RestrictedPercentage ob = RestrictedPercentage();
                 IDManager.SetID(limitationPercentageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 limitationPercentageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 limitationPercentage = new RestrictedPercentage(item);
             }
         }
     }
     
 
     XmlNodeList limitationPeriodNodeList = xmlNode.SelectNodes("limitationPeriod");
     if (limitationPeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in limitationPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 limitationPeriodIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(limitationPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 limitationPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 limitationPeriod = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
 }
 public MultipleExercise(XmlNode xmlNode)
 {
     XmlNodeList notionalReferenceNodeList = xmlNode.SelectNodes("notionalReference");
     
     foreach (XmlNode item in notionalReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notionalReferenceIDRef = item.Attributes["id"].Name;
                 List<NotionalReference> ob = new List<NotionalReference>();
                 ob.Add(new NotionalReference(item));
                 IDManager.SetID(notionalReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
             notionalReference.Add(new NotionalReference(item));
             }
         }
     }
     
 
     XmlNodeList integralMultipleAmountNodeList = xmlNode.SelectNodes("integralMultipleAmount");
     if (integralMultipleAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in integralMultipleAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 integralMultipleAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(integralMultipleAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 integralMultipleAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 integralMultipleAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList minimumNotionalAmountNodeList = xmlNode.SelectNodes("minimumNotionalAmount");
     if (minimumNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumNotionalAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(minimumNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimumNotionalAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList minimumNumberOfOptionsNodeList = xmlNode.SelectNodes("minimumNumberOfOptions");
     if (minimumNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(minimumNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimumNumberOfOptions = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList maximumNotionalAmountNodeList = xmlNode.SelectNodes("maximumNotionalAmount");
     if (maximumNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumNotionalAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(maximumNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumNotionalAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList maximumNumberOfOptionsNodeList = xmlNode.SelectNodes("maximumNumberOfOptions");
     if (maximumNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(maximumNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumNumberOfOptions = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public CommodityMarketDisruption(XmlNode xmlNode)
 {
     XmlNodeList marketDisruptionEventsNodeList = xmlNode.SelectNodes("marketDisruptionEvents");
     if (marketDisruptionEventsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in marketDisruptionEventsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 marketDisruptionEventsIDRef = item.Attributes["id"].Name;
                 MarketDisruptionEventsEnum ob = MarketDisruptionEventsEnum();
                 IDManager.SetID(marketDisruptionEventsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 marketDisruptionEventsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 marketDisruptionEvents = new MarketDisruptionEventsEnum(item);
             }
         }
     }
     
 
     XmlNodeList additionalMarketDisruptionEventNodeList = xmlNode.SelectNodes("additionalMarketDisruptionEvent");
     
     foreach (XmlNode item in additionalMarketDisruptionEventNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 additionalMarketDisruptionEventIDRef = item.Attributes["id"].Name;
                 List<MarketDisruptionEvent> ob = new List<MarketDisruptionEvent>();
                 ob.Add(new MarketDisruptionEvent(item));
                 IDManager.SetID(additionalMarketDisruptionEventIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 additionalMarketDisruptionEventIDRef = item.Attributes["href"].Name;
             }
             else
             {
             additionalMarketDisruptionEvent.Add(new MarketDisruptionEvent(item));
             }
         }
     }
     
 
     XmlNodeList marketDisruptionEventNodeList = xmlNode.SelectNodes("marketDisruptionEvent");
     
     foreach (XmlNode item in marketDisruptionEventNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 marketDisruptionEventIDRef = item.Attributes["id"].Name;
                 List<MarketDisruptionEvent> ob = new List<MarketDisruptionEvent>();
                 ob.Add(new MarketDisruptionEvent(item));
                 IDManager.SetID(marketDisruptionEventIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 marketDisruptionEventIDRef = item.Attributes["href"].Name;
             }
             else
             {
             marketDisruptionEvent.Add(new MarketDisruptionEvent(item));
             }
         }
     }
     
 
     XmlNodeList disruptionFallbacksNodeList = xmlNode.SelectNodes("disruptionFallbacks");
     if (disruptionFallbacksNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in disruptionFallbacksNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 disruptionFallbacksIDRef = item.Attributes["id"].Name;
                 DisruptionFallbacksEnum ob = DisruptionFallbacksEnum();
                 IDManager.SetID(disruptionFallbacksIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 disruptionFallbacksIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 disruptionFallbacks = new DisruptionFallbacksEnum(item);
             }
         }
     }
     
 
     XmlNodeList disruptionFallbackNodeList = xmlNode.SelectNodes("disruptionFallback");
     
     foreach (XmlNode item in disruptionFallbackNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 disruptionFallbackIDRef = item.Attributes["id"].Name;
                 List<SequencedDisruptionFallback> ob = new List<SequencedDisruptionFallback>();
                 ob.Add(new SequencedDisruptionFallback(item));
                 IDManager.SetID(disruptionFallbackIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 disruptionFallbackIDRef = item.Attributes["href"].Name;
             }
             else
             {
             disruptionFallback.Add(new SequencedDisruptionFallback(item));
             }
         }
     }
     
 
     XmlNodeList fallbackReferencePriceNodeList = xmlNode.SelectNodes("fallbackReferencePrice");
     if (fallbackReferencePriceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fallbackReferencePriceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fallbackReferencePriceIDRef = item.Attributes["id"].Name;
                 Underlyer ob = Underlyer();
                 IDManager.SetID(fallbackReferencePriceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fallbackReferencePriceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fallbackReferencePrice = new Underlyer(item);
             }
         }
     }
     
 
     XmlNodeList maximumNumberOfDaysOfDisruptionNodeList = xmlNode.SelectNodes("maximumNumberOfDaysOfDisruption");
     if (maximumNumberOfDaysOfDisruptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumNumberOfDaysOfDisruptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumNumberOfDaysOfDisruptionIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(maximumNumberOfDaysOfDisruptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumNumberOfDaysOfDisruptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumNumberOfDaysOfDisruption = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList priceMaterialityPercentageNodeList = xmlNode.SelectNodes("priceMaterialityPercentage");
     if (priceMaterialityPercentageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in priceMaterialityPercentageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 priceMaterialityPercentageIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(priceMaterialityPercentageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 priceMaterialityPercentageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 priceMaterialityPercentage = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList minimumFuturesContractsNodeList = xmlNode.SelectNodes("minimumFuturesContracts");
     if (minimumFuturesContractsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumFuturesContractsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumFuturesContractsIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(minimumFuturesContractsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumFuturesContractsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimumFuturesContracts = new XsdTypePositiveInteger(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 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 AssetPool(XmlNode xmlNode)
 {
     XmlNodeList versionNodeList = xmlNode.SelectNodes("version");
     if (versionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in versionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 versionIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(versionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 versionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 version = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList effectiveDateNodeList = xmlNode.SelectNodes("effectiveDate");
     if (effectiveDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in effectiveDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 effectiveDateIDRef = item.Attributes["id"].Name;
                 IdentifiedDate ob = IdentifiedDate();
                 IDManager.SetID(effectiveDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 effectiveDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 effectiveDate = new IdentifiedDate(item);
             }
         }
     }
     
 
     XmlNodeList initialFactorNodeList = xmlNode.SelectNodes("initialFactor");
     if (initialFactorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in initialFactorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 initialFactorIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(initialFactorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 initialFactorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 initialFactor = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList currentFactorNodeList = xmlNode.SelectNodes("currentFactor");
     if (currentFactorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currentFactorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currentFactorIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(currentFactorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currentFactorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currentFactor = new XsdTypeDecimal(item);
             }
         }
     }
     
 
 }
 public EquityValuation(XmlNode 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;
                 AdjustableDateOrRelativeDateSequence ob = AdjustableDateOrRelativeDateSequence();
                 IDManager.SetID(valuationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationDate = new AdjustableDateOrRelativeDateSequence(item);
             }
         }
     }
     
 
     XmlNodeList valuationDatesNodeList = xmlNode.SelectNodes("valuationDates");
     if (valuationDatesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationDatesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationDatesIDRef = item.Attributes["id"].Name;
                 AdjustableRelativeOrPeriodicDates ob = AdjustableRelativeOrPeriodicDates();
                 IDManager.SetID(valuationDatesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationDatesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationDates = new AdjustableRelativeOrPeriodicDates(item);
             }
         }
     }
     
 
     XmlNodeList valuationTimeTypeNodeList = xmlNode.SelectNodes("valuationTimeType");
     if (valuationTimeTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationTimeTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationTimeTypeIDRef = item.Attributes["id"].Name;
                 TimeTypeEnum ob = TimeTypeEnum();
                 IDManager.SetID(valuationTimeTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationTimeTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationTimeType = new TimeTypeEnum(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 futuresPriceValuationNodeList = xmlNode.SelectNodes("futuresPriceValuation");
     if (futuresPriceValuationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in futuresPriceValuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 futuresPriceValuationIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(futuresPriceValuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 futuresPriceValuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 futuresPriceValuation = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList optionsPriceValuationNodeList = xmlNode.SelectNodes("optionsPriceValuation");
     if (optionsPriceValuationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in optionsPriceValuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 optionsPriceValuationIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(optionsPriceValuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 optionsPriceValuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 optionsPriceValuation = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList numberOfValuationDatesNodeList = xmlNode.SelectNodes("numberOfValuationDates");
     if (numberOfValuationDatesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberOfValuationDatesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberOfValuationDatesIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(numberOfValuationDatesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberOfValuationDatesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 numberOfValuationDates = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList dividendValuationDatesNodeList = xmlNode.SelectNodes("dividendValuationDates");
     if (dividendValuationDatesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendValuationDatesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendValuationDatesIDRef = item.Attributes["id"].Name;
                 AdjustableRelativeOrPeriodicDates ob = AdjustableRelativeOrPeriodicDates();
                 IDManager.SetID(dividendValuationDatesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendValuationDatesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendValuationDates = new AdjustableRelativeOrPeriodicDates(item);
             }
         }
     }
     
 
     XmlNodeList fPVFinalPriceElectionFallbackNodeList = xmlNode.SelectNodes("fPVFinalPriceElectionFallback");
     if (fPVFinalPriceElectionFallbackNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fPVFinalPriceElectionFallbackNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fPVFinalPriceElectionFallbackIDRef = item.Attributes["id"].Name;
                 FPVFinalPriceElectionFallbackEnum ob = FPVFinalPriceElectionFallbackEnum();
                 IDManager.SetID(fPVFinalPriceElectionFallbackIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fPVFinalPriceElectionFallbackIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fPVFinalPriceElectionFallback = new FPVFinalPriceElectionFallbackEnum(item);
             }
         }
     }
     
 
 }
 public VersionedTradeId(XmlNode xmlNode)
 {
     XmlNodeList tradeIdNodeList = xmlNode.SelectNodes("tradeId");
     if (tradeIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tradeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tradeIdIDRef = item.Attributes["id"].Name;
                 TradeId ob = TradeId();
                 IDManager.SetID(tradeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tradeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tradeId = new TradeId(item);
             }
         }
     }
     
 
     XmlNodeList versionNodeList = xmlNode.SelectNodes("version");
     if (versionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in versionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 versionIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(versionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 versionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 version = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList effectiveDateNodeList = xmlNode.SelectNodes("effectiveDate");
     if (effectiveDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in effectiveDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 effectiveDateIDRef = item.Attributes["id"].Name;
                 IdentifiedDate ob = IdentifiedDate();
                 IDManager.SetID(effectiveDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 effectiveDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 effectiveDate = new IdentifiedDate(item);
             }
         }
     }
     
 
 }
 public PhysicalSettlementPeriod(XmlNode xmlNode)
 {
     XmlNodeList businessDaysNotSpecifiedNodeList = xmlNode.SelectNodes("businessDaysNotSpecified");
     if (businessDaysNotSpecifiedNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in businessDaysNotSpecifiedNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 businessDaysNotSpecifiedIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(businessDaysNotSpecifiedIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 businessDaysNotSpecifiedIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 businessDaysNotSpecified = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList businessDaysNodeList = xmlNode.SelectNodes("businessDays");
     if (businessDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in businessDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 businessDaysIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(businessDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 businessDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 businessDays = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList maximumBusinessDaysNodeList = xmlNode.SelectNodes("maximumBusinessDays");
     if (maximumBusinessDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumBusinessDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumBusinessDaysIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(maximumBusinessDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumBusinessDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumBusinessDays = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
 }