public CommodityCalculationPeriodsSchedule(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList balanceOfFirstPeriodNodeList = xmlNode.SelectNodes("balanceOfFirstPeriod");
     if (balanceOfFirstPeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in balanceOfFirstPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 balanceOfFirstPeriodIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(balanceOfFirstPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 balanceOfFirstPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 balanceOfFirstPeriod = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public ElectricityDeliveryFirm(XmlNode xmlNode)
 {
     XmlNodeList forceMajeureNodeList = xmlNode.SelectNodes("forceMajeure");
     if (forceMajeureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in forceMajeureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 forceMajeureIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(forceMajeureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 forceMajeureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 forceMajeure = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public PortfolioReference(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");
     if (sequenceNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sequenceNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(sequenceNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sequenceNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sequenceNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList submissionsCompleteNodeList = xmlNode.SelectNodes("submissionsComplete");
     if (submissionsCompleteNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in submissionsCompleteNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 submissionsCompleteIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(submissionsCompleteIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 submissionsCompleteIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 submissionsComplete = new XsdTypeBoolean(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 ReportIdentification(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList numberOfSectionsNodeList = xmlNode.SelectNodes("numberOfSections");
     if (numberOfSectionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberOfSectionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberOfSectionsIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(numberOfSectionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberOfSectionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 numberOfSections = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList submissionsCompleteNodeList = xmlNode.SelectNodes("submissionsComplete");
     if (submissionsCompleteNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in submissionsCompleteNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 submissionsCompleteIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(submissionsCompleteIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 submissionsCompleteIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 submissionsComplete = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public SwaptionPhysicalSettlement(XmlNode xmlNode)
 {
     XmlNodeList clearedPhysicalSettlementNodeList = xmlNode.SelectNodes("clearedPhysicalSettlement");
     if (clearedPhysicalSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in clearedPhysicalSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 clearedPhysicalSettlementIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(clearedPhysicalSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 clearedPhysicalSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 clearedPhysicalSettlement = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public SubEvent(XmlNode xmlNode)
 {
     XmlNodeList refEventIDNodeList = xmlNode.SelectNodes("refEventID");
     if (refEventIDNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in refEventIDNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 refEventIDIDRef = item.Attributes["id"].Name;
                 XsdTypeToken ob = XsdTypeToken();
                 IDManager.SetID(refEventIDIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 refEventIDIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 refEventID = new XsdTypeToken(item);
             }
         }
     }
     
 
     XmlNodeList truefalseNodeList = xmlNode.SelectNodes("truefalse");
     if (truefalseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in truefalseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 truefalseIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(truefalseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 truefalseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 truefalse = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public ManualExercise(XmlNode xmlNode)
 {
     XmlNodeList exerciseNoticeNodeList = xmlNode.SelectNodes("exerciseNotice");
     if (exerciseNoticeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseNoticeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseNoticeIDRef = item.Attributes["id"].Name;
                 ExerciseNotice ob = ExerciseNotice();
                 IDManager.SetID(exerciseNoticeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseNoticeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseNotice = new ExerciseNotice(item);
             }
         }
     }
     
 
     XmlNodeList fallbackExerciseNodeList = xmlNode.SelectNodes("fallbackExercise");
     if (fallbackExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fallbackExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fallbackExerciseIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(fallbackExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fallbackExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fallbackExercise = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public OilTransferDelivery(XmlNode xmlNode)
 {
     XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");
     if (applicableNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in applicableNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 applicableIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(applicableIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 applicableIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 applicable = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList deliveryLocationNodeList = xmlNode.SelectNodes("deliveryLocation");
     if (deliveryLocationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in deliveryLocationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 deliveryLocationIDRef = item.Attributes["id"].Name;
                 CommodityDeliveryPoint ob = CommodityDeliveryPoint();
                 IDManager.SetID(deliveryLocationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 deliveryLocationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 deliveryLocation = new CommodityDeliveryPoint(item);
             }
         }
     }
     
 
 }
 public FxBoundary(XmlNode xmlNode)
 {
     XmlNodeList inclusiveNodeList = xmlNode.SelectNodes("inclusive");
     if (inclusiveNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in inclusiveNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 inclusiveIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(inclusiveIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 inclusiveIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 inclusive = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList exclusiveNodeList = xmlNode.SelectNodes("exclusive");
     if (exclusiveNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exclusiveNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exclusiveIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(exclusiveIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exclusiveIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exclusive = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public UpDownEventCheck(XmlNode xmlNode)
 {
     XmlNodeList checkValueNodeList = xmlNode.SelectNodes("checkValue");
     if (checkValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in checkValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 checkValueIDRef = item.Attributes["id"].Name;
                 XsdTypeDouble ob = XsdTypeDouble();
                 IDManager.SetID(checkValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 checkValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 checkValue = new XsdTypeDouble(item);
             }
         }
     }
     
 
     XmlNodeList equalityNodeList = xmlNode.SelectNodes("equality");
     if (equalityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equalityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equalityIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(equalityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equalityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equality = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public FloatingAmountProvisions(XmlNode xmlNode)
 {
     XmlNodeList WACCapInterestProvisionNodeList = xmlNode.SelectNodes("WACCapInterestProvision");
     if (WACCapInterestProvisionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in WACCapInterestProvisionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 WACCapInterestProvisionIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(WACCapInterestProvisionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 WACCapInterestProvisionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 WACCapInterestProvision = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList stepUpProvisionNodeList = xmlNode.SelectNodes("stepUpProvision");
     if (stepUpProvisionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in stepUpProvisionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 stepUpProvisionIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(stepUpProvisionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 stepUpProvisionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 stepUpProvision = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public GracePeriodExtension(XmlNode xmlNode)
 {
     XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");
     if (applicableNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in applicableNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 applicableIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(applicableIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 applicableIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 applicable = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList gracePeriodNodeList = xmlNode.SelectNodes("gracePeriod");
     if (gracePeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in gracePeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 gracePeriodIDRef = item.Attributes["id"].Name;
                 Offset ob = Offset();
                 IDManager.SetID(gracePeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 gracePeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 gracePeriod = new Offset(item);
             }
         }
     }
     
 
 }
 public NotDomesticCurrency(XmlNode xmlNode)
 {
     XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");
     if (applicableNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in applicableNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 applicableIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(applicableIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 applicableIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 applicable = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList currencyNodeList = xmlNode.SelectNodes("currency");
     if (currencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currencyIDRef = item.Attributes["id"].Name;
                 Currency ob = Currency();
                 IDManager.SetID(currencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currency = new Currency(item);
             }
         }
     }
     
 
 }
 public PCDeliverableObligationCharac(XmlNode xmlNode)
 {
     XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");
     if (applicableNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in applicableNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 applicableIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(applicableIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 applicableIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 applicable = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList partialCashSettlementNodeList = xmlNode.SelectNodes("partialCashSettlement");
     if (partialCashSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in partialCashSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 partialCashSettlementIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(partialCashSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 partialCashSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 partialCashSettlement = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public ElectricityDeliveryUnitFirm(XmlNode xmlNode)
 {
     XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");
     if (applicableNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in applicableNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 applicableIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(applicableIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 applicableIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 applicable = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList generationAssetNodeList = xmlNode.SelectNodes("generationAsset");
     if (generationAssetNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in generationAssetNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 generationAssetIDRef = item.Attributes["id"].Name;
                 CommodityDeliveryPoint ob = CommodityDeliveryPoint();
                 IDManager.SetID(generationAssetIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 generationAssetIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 generationAsset = new CommodityDeliveryPoint(item);
             }
         }
     }
     
 
 }
 public ExtraordinaryEvents(XmlNode xmlNode)
 {
     XmlNodeList mergerEventsNodeList = xmlNode.SelectNodes("mergerEvents");
     if (mergerEventsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mergerEventsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mergerEventsIDRef = item.Attributes["id"].Name;
                 EquityCorporateEvents ob = EquityCorporateEvents();
                 IDManager.SetID(mergerEventsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mergerEventsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mergerEvents = new EquityCorporateEvents(item);
             }
         }
     }
     
 
     XmlNodeList tenderOfferNodeList = xmlNode.SelectNodes("tenderOffer");
     if (tenderOfferNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tenderOfferNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tenderOfferIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(tenderOfferIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tenderOfferIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tenderOffer = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList tenderOfferEventsNodeList = xmlNode.SelectNodes("tenderOfferEvents");
     if (tenderOfferEventsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tenderOfferEventsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tenderOfferEventsIDRef = item.Attributes["id"].Name;
                 EquityCorporateEvents ob = EquityCorporateEvents();
                 IDManager.SetID(tenderOfferEventsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tenderOfferEventsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tenderOfferEvents = new EquityCorporateEvents(item);
             }
         }
     }
     
 
     XmlNodeList compositionOfCombinedConsiderationNodeList = xmlNode.SelectNodes("compositionOfCombinedConsideration");
     if (compositionOfCombinedConsiderationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in compositionOfCombinedConsiderationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 compositionOfCombinedConsiderationIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(compositionOfCombinedConsiderationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 compositionOfCombinedConsiderationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 compositionOfCombinedConsideration = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList indexAdjustmentEventsNodeList = xmlNode.SelectNodes("indexAdjustmentEvents");
     if (indexAdjustmentEventsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in indexAdjustmentEventsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexAdjustmentEventsIDRef = item.Attributes["id"].Name;
                 IndexAdjustmentEvents ob = IndexAdjustmentEvents();
                 IDManager.SetID(indexAdjustmentEventsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexAdjustmentEventsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 indexAdjustmentEvents = new IndexAdjustmentEvents(item);
             }
         }
     }
     
 
     XmlNodeList additionalDisruptionEventsNodeList = xmlNode.SelectNodes("additionalDisruptionEvents");
     if (additionalDisruptionEventsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in additionalDisruptionEventsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 additionalDisruptionEventsIDRef = item.Attributes["id"].Name;
                 AdditionalDisruptionEvents ob = AdditionalDisruptionEvents();
                 IDManager.SetID(additionalDisruptionEventsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 additionalDisruptionEventsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 additionalDisruptionEvents = new AdditionalDisruptionEvents(item);
             }
         }
     }
     
 
     XmlNodeList failureToDeliverNodeList = xmlNode.SelectNodes("failureToDeliver");
     if (failureToDeliverNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in failureToDeliverNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 failureToDeliverIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(failureToDeliverIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 failureToDeliverIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 failureToDeliver = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList representationsNodeList = xmlNode.SelectNodes("representations");
     if (representationsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in representationsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 representationsIDRef = item.Attributes["id"].Name;
                 Representations ob = Representations();
                 IDManager.SetID(representationsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 representationsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 representations = new Representations(item);
             }
         }
     }
     
 
     XmlNodeList nationalisationOrInsolvencyNodeList = xmlNode.SelectNodes("nationalisationOrInsolvency");
     if (nationalisationOrInsolvencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nationalisationOrInsolvencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nationalisationOrInsolvencyIDRef = item.Attributes["id"].Name;
                 NationalisationOrInsolvencyOrDelistingEventEnum ob = NationalisationOrInsolvencyOrDelistingEventEnum();
                 IDManager.SetID(nationalisationOrInsolvencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nationalisationOrInsolvencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 nationalisationOrInsolvency = new NationalisationOrInsolvencyOrDelistingEventEnum(item);
             }
         }
     }
     
 
     XmlNodeList delistingNodeList = xmlNode.SelectNodes("delisting");
     if (delistingNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in delistingNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 delistingIDRef = item.Attributes["id"].Name;
                 NationalisationOrInsolvencyOrDelistingEventEnum ob = NationalisationOrInsolvencyOrDelistingEventEnum();
                 IDManager.SetID(delistingIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 delistingIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 delisting = new NationalisationOrInsolvencyOrDelistingEventEnum(item);
             }
         }
     }
     
 
     XmlNodeList relatedExchangeIdNodeList = xmlNode.SelectNodes("relatedExchangeId");
     
     foreach (XmlNode item in relatedExchangeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 relatedExchangeIdIDRef = item.Attributes["id"].Name;
                 List<ExchangeId> ob = new List<ExchangeId>();
                 ob.Add(new ExchangeId(item));
                 IDManager.SetID(relatedExchangeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 relatedExchangeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             relatedExchangeId.Add(new ExchangeId(item));
             }
         }
     }
     
 
     XmlNodeList optionsExchangeIdNodeList = xmlNode.SelectNodes("optionsExchangeId");
     
     foreach (XmlNode item in optionsExchangeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 optionsExchangeIdIDRef = item.Attributes["id"].Name;
                 List<ExchangeId> ob = new List<ExchangeId>();
                 ob.Add(new ExchangeId(item));
                 IDManager.SetID(optionsExchangeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 optionsExchangeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             optionsExchangeId.Add(new ExchangeId(item));
             }
         }
     }
     
 
     XmlNodeList specifiedExchangeIdNodeList = xmlNode.SelectNodes("specifiedExchangeId");
     
     foreach (XmlNode item in specifiedExchangeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 specifiedExchangeIdIDRef = item.Attributes["id"].Name;
                 List<ExchangeId> ob = new List<ExchangeId>();
                 ob.Add(new ExchangeId(item));
                 IDManager.SetID(specifiedExchangeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 specifiedExchangeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             specifiedExchangeId.Add(new ExchangeId(item));
             }
         }
     }
     
 
 }
 public BoundedVariance(XmlNode xmlNode)
 {
     XmlNodeList realisedVarianceMethodNodeList = xmlNode.SelectNodes("realisedVarianceMethod");
     if (realisedVarianceMethodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in realisedVarianceMethodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 realisedVarianceMethodIDRef = item.Attributes["id"].Name;
                 RealisedVarianceMethodEnum ob = RealisedVarianceMethodEnum();
                 IDManager.SetID(realisedVarianceMethodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 realisedVarianceMethodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 realisedVarianceMethod = new RealisedVarianceMethodEnum(item);
             }
         }
     }
     
 
     XmlNodeList daysInRangeAdjustmentNodeList = xmlNode.SelectNodes("daysInRangeAdjustment");
     if (daysInRangeAdjustmentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in daysInRangeAdjustmentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 daysInRangeAdjustmentIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(daysInRangeAdjustmentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 daysInRangeAdjustmentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 daysInRangeAdjustment = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList upperBarrierNodeList = xmlNode.SelectNodes("upperBarrier");
     if (upperBarrierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in upperBarrierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 upperBarrierIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(upperBarrierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 upperBarrierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 upperBarrier = new NonNegativeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList lowerBarrierNodeList = xmlNode.SelectNodes("lowerBarrier");
     if (lowerBarrierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in lowerBarrierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 lowerBarrierIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(lowerBarrierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 lowerBarrierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 lowerBarrier = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
 public SingleUnderlyer(XmlNode xmlNode)
 {
     XmlNodeList underlyingAssetNodeList = xmlNode.SelectNodes("underlyingAsset");
     if (underlyingAssetNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in underlyingAssetNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 underlyingAssetIDRef = item.Attributes["id"].Name;
                 Asset ob = Asset();
                 IDManager.SetID(underlyingAssetIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 underlyingAssetIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 underlyingAsset = new Asset(item);
             }
         }
     }
     
 
     XmlNodeList basketNodeList = xmlNode.SelectNodes("basket");
     if (basketNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in basketNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 basketIDRef = item.Attributes["id"].Name;
                 Basket ob = Basket();
                 IDManager.SetID(basketIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 basketIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 basket = new Basket(item);
             }
         }
     }
     
 
     XmlNodeList bondNodeList = xmlNode.SelectNodes("bond");
     if (bondNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in bondNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 bondIDRef = item.Attributes["id"].Name;
                 Bond ob = Bond();
                 IDManager.SetID(bondIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 bondIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 bond = new Bond(item);
             }
         }
     }
     
 
     XmlNodeList cashNodeList = xmlNode.SelectNodes("cash");
     if (cashNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cashNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cashIDRef = item.Attributes["id"].Name;
                 Cash ob = Cash();
                 IDManager.SetID(cashIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cashIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cash = new Cash(item);
             }
         }
     }
     
 
     XmlNodeList commodityNodeList = xmlNode.SelectNodes("commodity");
     if (commodityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in commodityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 commodityIDRef = item.Attributes["id"].Name;
                 Commodity ob = Commodity();
                 IDManager.SetID(commodityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 commodityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 commodity = new Commodity(item);
             }
         }
     }
     
 
     XmlNodeList convertibleBondNodeList = xmlNode.SelectNodes("convertibleBond");
     if (convertibleBondNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in convertibleBondNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 convertibleBondIDRef = item.Attributes["id"].Name;
                 ConvertibleBond ob = ConvertibleBond();
                 IDManager.SetID(convertibleBondIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 convertibleBondIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 convertibleBond = new ConvertibleBond(item);
             }
         }
     }
     
 
     XmlNodeList equityNodeList = xmlNode.SelectNodes("equity");
     if (equityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityIDRef = item.Attributes["id"].Name;
                 EquityAsset ob = EquityAsset();
                 IDManager.SetID(equityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equity = new EquityAsset(item);
             }
         }
     }
     
 
     XmlNodeList exchangeTradedFundNodeList = xmlNode.SelectNodes("exchangeTradedFund");
     if (exchangeTradedFundNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangeTradedFundNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangeTradedFundIDRef = item.Attributes["id"].Name;
                 ExchangeTradedFund ob = ExchangeTradedFund();
                 IDManager.SetID(exchangeTradedFundIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangeTradedFundIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangeTradedFund = new ExchangeTradedFund(item);
             }
         }
     }
     
 
     XmlNodeList futureNodeList = xmlNode.SelectNodes("future");
     if (futureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in futureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 futureIDRef = item.Attributes["id"].Name;
                 Future ob = Future();
                 IDManager.SetID(futureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 futureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 future = new Future(item);
             }
         }
     }
     
 
     XmlNodeList indexNodeList = xmlNode.SelectNodes("index");
     if (indexNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in indexNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexIDRef = item.Attributes["id"].Name;
                 Index ob = Index();
                 IDManager.SetID(indexIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 index = new Index(item);
             }
         }
     }
     
 
     XmlNodeList loanNodeList = xmlNode.SelectNodes("loan");
     if (loanNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in loanNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 loanIDRef = item.Attributes["id"].Name;
                 Loan ob = Loan();
                 IDManager.SetID(loanIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 loanIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 loan = new Loan(item);
             }
         }
     }
     
 
     XmlNodeList mortgageNodeList = xmlNode.SelectNodes("mortgage");
     if (mortgageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mortgageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mortgageIDRef = item.Attributes["id"].Name;
                 Mortgage ob = Mortgage();
                 IDManager.SetID(mortgageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mortgageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mortgage = new Mortgage(item);
             }
         }
     }
     
 
     XmlNodeList mutualFundNodeList = xmlNode.SelectNodes("mutualFund");
     if (mutualFundNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mutualFundNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mutualFundIDRef = item.Attributes["id"].Name;
                 MutualFund ob = MutualFund();
                 IDManager.SetID(mutualFundIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mutualFundIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mutualFund = new MutualFund(item);
             }
         }
     }
     
 
     XmlNodeList openUnitsNodeList = xmlNode.SelectNodes("openUnits");
     if (openUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in openUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 openUnitsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(openUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 openUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 openUnits = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList dividendPayoutNodeList = xmlNode.SelectNodes("dividendPayout");
     if (dividendPayoutNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendPayoutNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendPayoutIDRef = item.Attributes["id"].Name;
                 DividendPayout ob = DividendPayout();
                 IDManager.SetID(dividendPayoutIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendPayoutIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendPayout = new DividendPayout(item);
             }
         }
     }
     
 
     XmlNodeList couponPaymentNodeList = xmlNode.SelectNodes("couponPayment");
     if (couponPaymentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in couponPaymentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 couponPaymentIDRef = item.Attributes["id"].Name;
                 PendingPayment ob = PendingPayment();
                 IDManager.SetID(couponPaymentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 couponPaymentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 couponPayment = new PendingPayment(item);
             }
         }
     }
     
 
     XmlNodeList averageDailyTradingVolumeNodeList = xmlNode.SelectNodes("averageDailyTradingVolume");
     if (averageDailyTradingVolumeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in averageDailyTradingVolumeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 averageDailyTradingVolumeIDRef = item.Attributes["id"].Name;
                 AverageDailyTradingVolumeLimit ob = AverageDailyTradingVolumeLimit();
                 IDManager.SetID(averageDailyTradingVolumeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 averageDailyTradingVolumeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 averageDailyTradingVolume = new AverageDailyTradingVolumeLimit(item);
             }
         }
     }
     
 
     XmlNodeList depositoryReceiptNodeList = xmlNode.SelectNodes("depositoryReceipt");
     if (depositoryReceiptNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in depositoryReceiptNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 depositoryReceiptIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(depositoryReceiptIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 depositoryReceiptIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 depositoryReceipt = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public WeatherLegCalculation(XmlNode xmlNode)
 {
     XmlNodeList settlementLevelNodeList = xmlNode.SelectNodes("settlementLevel");
     if (settlementLevelNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settlementLevelNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementLevelIDRef = item.Attributes["id"].Name;
                 WeatherSettlementLevelEnum ob = WeatherSettlementLevelEnum();
                 IDManager.SetID(settlementLevelIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementLevelIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settlementLevel = new WeatherSettlementLevelEnum(item);
             }
         }
     }
     
 
     XmlNodeList referenceLevelEqualsZeroNodeList = xmlNode.SelectNodes("referenceLevelEqualsZero");
     if (referenceLevelEqualsZeroNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in referenceLevelEqualsZeroNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 referenceLevelEqualsZeroIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(referenceLevelEqualsZeroIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 referenceLevelEqualsZeroIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 referenceLevelEqualsZero = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList calculationDateNodeList = xmlNode.SelectNodes("calculationDate");
     if (calculationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationDateIDRef = item.Attributes["id"].Name;
                 Period ob = Period();
                 IDManager.SetID(calculationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationDate = new Period(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;
                 BusinessCenter ob = BusinessCenter();
                 IDManager.SetID(businessDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 businessDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 businessDays = new BusinessCenter(item);
             }
         }
     }
     
 
     XmlNodeList dataCorrectionNodeList = xmlNode.SelectNodes("dataCorrection");
     if (dataCorrectionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dataCorrectionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dataCorrectionIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(dataCorrectionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dataCorrectionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dataCorrection = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList correctionPeriodNodeList = xmlNode.SelectNodes("correctionPeriod");
     if (correctionPeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in correctionPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 correctionPeriodIDRef = item.Attributes["id"].Name;
                 Period ob = Period();
                 IDManager.SetID(correctionPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 correctionPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 correctionPeriod = new Period(item);
             }
         }
     }
     
 
     XmlNodeList maximumPaymentAmountNodeList = xmlNode.SelectNodes("maximumPaymentAmount");
     if (maximumPaymentAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumPaymentAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumPaymentAmountIDRef = item.Attributes["id"].Name;
                 NonNegativeMoney ob = NonNegativeMoney();
                 IDManager.SetID(maximumPaymentAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumPaymentAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumPaymentAmount = new NonNegativeMoney(item);
             }
         }
     }
     
 
     XmlNodeList maximumTransactionPaymentAmountNodeList = xmlNode.SelectNodes("maximumTransactionPaymentAmount");
     if (maximumTransactionPaymentAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumTransactionPaymentAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumTransactionPaymentAmountIDRef = item.Attributes["id"].Name;
                 NonNegativeMoney ob = NonNegativeMoney();
                 IDManager.SetID(maximumTransactionPaymentAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumTransactionPaymentAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumTransactionPaymentAmount = new NonNegativeMoney(item);
             }
         }
     }
     
 
     XmlNodeList roundingNodeList = xmlNode.SelectNodes("rounding");
     if (roundingNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in roundingNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 roundingIDRef = item.Attributes["id"].Name;
                 Rounding ob = Rounding();
                 IDManager.SetID(roundingIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 roundingIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 rounding = new Rounding(item);
             }
         }
     }
     
 
 }
 public RangeEventCheck(XmlNode xmlNode)
 {
     XmlNodeList highCheckValueNodeList = xmlNode.SelectNodes("highCheckValue");
     if (highCheckValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in highCheckValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 highCheckValueIDRef = item.Attributes["id"].Name;
                 XsdTypeDouble ob = XsdTypeDouble();
                 IDManager.SetID(highCheckValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 highCheckValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 highCheckValue = new XsdTypeDouble(item);
             }
         }
     }
     
 
     XmlNodeList highEqualityNodeList = xmlNode.SelectNodes("highEquality");
     if (highEqualityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in highEqualityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 highEqualityIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(highEqualityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 highEqualityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 highEquality = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList lowCheckValueNodeList = xmlNode.SelectNodes("lowCheckValue");
     if (lowCheckValueNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in lowCheckValueNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 lowCheckValueIDRef = item.Attributes["id"].Name;
                 XsdTypeDouble ob = XsdTypeDouble();
                 IDManager.SetID(lowCheckValueIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 lowCheckValueIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 lowCheckValue = new XsdTypeDouble(item);
             }
         }
     }
     
 
     XmlNodeList lowEqualityNodeList = xmlNode.SelectNodes("lowEquality");
     if (lowEqualityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in lowEqualityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 lowEqualityIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(lowEqualityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 lowEqualityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 lowEquality = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public PrincipalExchanges(XmlNode xmlNode)
 {
     XmlNodeList initialExchangeNodeList = xmlNode.SelectNodes("initialExchange");
     if (initialExchangeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in initialExchangeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 initialExchangeIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(initialExchangeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 initialExchangeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 initialExchange = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList finalExchangeNodeList = xmlNode.SelectNodes("finalExchange");
     if (finalExchangeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in finalExchangeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 finalExchangeIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(finalExchangeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 finalExchangeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 finalExchange = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList intermediateExchangeNodeList = xmlNode.SelectNodes("intermediateExchange");
     if (intermediateExchangeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in intermediateExchangeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 intermediateExchangeIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(intermediateExchangeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 intermediateExchangeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 intermediateExchange = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public TradeNovationContent(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList newTradeIdentifierNodeList = xmlNode.SelectNodes("newTradeIdentifier");
     
     foreach (XmlNode item in newTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 newTradeIdentifierIDRef = item.Attributes["id"].Name;
                 List<PartyTradeIdentifier> ob = new List<PartyTradeIdentifier>();
                 ob.Add(new PartyTradeIdentifier(item));
                 IDManager.SetID(newTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 newTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
             newTradeIdentifier.Add(new PartyTradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList newTradeNodeList = xmlNode.SelectNodes("newTrade");
     if (newTradeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in newTradeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 newTradeIDRef = item.Attributes["id"].Name;
                 Trade ob = Trade();
                 IDManager.SetID(newTradeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 newTradeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 newTrade = new Trade(item);
             }
         }
     }
     
 
     XmlNodeList oldTradeIdentifierNodeList = xmlNode.SelectNodes("oldTradeIdentifier");
     
     foreach (XmlNode item in oldTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 oldTradeIdentifierIDRef = item.Attributes["id"].Name;
                 List<PartyTradeIdentifier> ob = new List<PartyTradeIdentifier>();
                 ob.Add(new PartyTradeIdentifier(item));
                 IDManager.SetID(oldTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 oldTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
             oldTradeIdentifier.Add(new PartyTradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList oldTradeNodeList = xmlNode.SelectNodes("oldTrade");
     if (oldTradeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in oldTradeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 oldTradeIDRef = item.Attributes["id"].Name;
                 Trade ob = Trade();
                 IDManager.SetID(oldTradeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 oldTradeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 oldTrade = new Trade(item);
             }
         }
     }
     
 
     XmlNodeList feeTradeIdentifierNodeList = xmlNode.SelectNodes("feeTradeIdentifier");
     if (feeTradeIdentifierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in feeTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 feeTradeIdentifierIDRef = item.Attributes["id"].Name;
                 PartyTradeIdentifier ob = PartyTradeIdentifier();
                 IDManager.SetID(feeTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 feeTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 feeTradeIdentifier = new PartyTradeIdentifier(item);
             }
         }
     }
     
 
     XmlNodeList feeTradeNodeList = xmlNode.SelectNodes("feeTrade");
     if (feeTradeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in feeTradeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 feeTradeIDRef = item.Attributes["id"].Name;
                 Trade ob = Trade();
                 IDManager.SetID(feeTradeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 feeTradeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 feeTrade = new Trade(item);
             }
         }
     }
     
 
     XmlNodeList transferorNodeList = xmlNode.SelectNodes("transferor");
     if (transferorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in transferorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 transferorIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(transferorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 transferorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 transferor = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList transferorAccountNodeList = xmlNode.SelectNodes("transferorAccount");
     if (transferorAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in transferorAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 transferorAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(transferorAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 transferorAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 transferorAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList transfereeNodeList = xmlNode.SelectNodes("transferee");
     if (transfereeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in transfereeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 transfereeIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(transfereeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 transfereeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 transferee = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList otherTransfereeNodeList = xmlNode.SelectNodes("otherTransferee");
     if (otherTransfereeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherTransfereeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherTransfereeIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(otherTransfereeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherTransfereeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherTransferee = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList transfereeAccountNodeList = xmlNode.SelectNodes("transfereeAccount");
     if (transfereeAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in transfereeAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 transfereeAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(transfereeAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 transfereeAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 transfereeAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList otherTransfereeAccountNodeList = xmlNode.SelectNodes("otherTransfereeAccount");
     if (otherTransfereeAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherTransfereeAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherTransfereeAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(otherTransfereeAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherTransfereeAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherTransfereeAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList remainingPartyNodeList = xmlNode.SelectNodes("remainingParty");
     if (remainingPartyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in remainingPartyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingPartyIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(remainingPartyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingPartyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 remainingParty = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList remainingPartyAccountNodeList = xmlNode.SelectNodes("remainingPartyAccount");
     if (remainingPartyAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in remainingPartyAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingPartyAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(remainingPartyAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingPartyAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 remainingPartyAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList otherRemainingPartyNodeList = xmlNode.SelectNodes("otherRemainingParty");
     if (otherRemainingPartyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherRemainingPartyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherRemainingPartyIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(otherRemainingPartyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherRemainingPartyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherRemainingParty = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList otherRemainingPartyAccountNodeList = xmlNode.SelectNodes("otherRemainingPartyAccount");
     if (otherRemainingPartyAccountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in otherRemainingPartyAccountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherRemainingPartyAccountIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(otherRemainingPartyAccountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherRemainingPartyAccountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 otherRemainingPartyAccount = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList novationDateNodeList = xmlNode.SelectNodes("novationDate");
     if (novationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in novationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(novationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 novationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList executionDateTimeNodeList = xmlNode.SelectNodes("executionDateTime");
     if (executionDateTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in executionDateTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 executionDateTimeIDRef = item.Attributes["id"].Name;
                 ExecutionDateTime ob = ExecutionDateTime();
                 IDManager.SetID(executionDateTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 executionDateTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 executionDateTime = new ExecutionDateTime(item);
             }
         }
     }
     
 
     XmlNodeList novationTradeDateNodeList = xmlNode.SelectNodes("novationTradeDate");
     if (novationTradeDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in novationTradeDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novationTradeDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(novationTradeDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novationTradeDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 novationTradeDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList novatedAmountNodeList = xmlNode.SelectNodes("novatedAmount");
     
     foreach (XmlNode item in novatedAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novatedAmountIDRef = item.Attributes["id"].Name;
                 List<Money> ob = new List<Money>();
                 ob.Add(new Money(item));
                 IDManager.SetID(novatedAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novatedAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
             novatedAmount.Add(new Money(item));
             }
         }
     }
     
 
     XmlNodeList remainingAmountNodeList = xmlNode.SelectNodes("remainingAmount");
     
     foreach (XmlNode item in remainingAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingAmountIDRef = item.Attributes["id"].Name;
                 List<Money> ob = new List<Money>();
                 ob.Add(new Money(item));
                 IDManager.SetID(remainingAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
             remainingAmount.Add(new Money(item));
             }
         }
     }
     
 
     XmlNodeList novatedNumberOfOptionsNodeList = xmlNode.SelectNodes("novatedNumberOfOptions");
     if (novatedNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in novatedNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novatedNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(novatedNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novatedNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 novatedNumberOfOptions = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList remainingNumberOfOptionsNodeList = xmlNode.SelectNodes("remainingNumberOfOptions");
     if (remainingNumberOfOptionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in remainingNumberOfOptionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingNumberOfOptionsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(remainingNumberOfOptionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingNumberOfOptionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 remainingNumberOfOptions = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList novatedNumberOfUnitsNodeList = xmlNode.SelectNodes("novatedNumberOfUnits");
     if (novatedNumberOfUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in novatedNumberOfUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 novatedNumberOfUnitsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(novatedNumberOfUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 novatedNumberOfUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 novatedNumberOfUnits = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList remainingNumberOfUnitsNodeList = xmlNode.SelectNodes("remainingNumberOfUnits");
     if (remainingNumberOfUnitsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in remainingNumberOfUnitsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 remainingNumberOfUnitsIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(remainingNumberOfUnitsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 remainingNumberOfUnitsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 remainingNumberOfUnits = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList fullFirstCalculationPeriodNodeList = xmlNode.SelectNodes("fullFirstCalculationPeriod");
     if (fullFirstCalculationPeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fullFirstCalculationPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fullFirstCalculationPeriodIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(fullFirstCalculationPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fullFirstCalculationPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fullFirstCalculationPeriod = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList firstPeriodStartDateNodeList = xmlNode.SelectNodes("firstPeriodStartDate");
     
     foreach (XmlNode item in firstPeriodStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 firstPeriodStartDateIDRef = item.Attributes["id"].Name;
                 List<FirstPeriodStartDate> ob = new List<FirstPeriodStartDate>();
                 ob.Add(new FirstPeriodStartDate(item));
                 IDManager.SetID(firstPeriodStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 firstPeriodStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
             firstPeriodStartDate.Add(new FirstPeriodStartDate(item));
             }
         }
     }
     
 
     XmlNodeList nonRelianceNodeList = xmlNode.SelectNodes("nonReliance");
     if (nonRelianceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nonRelianceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nonRelianceIDRef = item.Attributes["id"].Name;
                 Empty ob = Empty();
                 IDManager.SetID(nonRelianceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nonRelianceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 nonReliance = new Empty(item);
             }
         }
     }
     
 
     XmlNodeList creditDerivativesNoticesNodeList = xmlNode.SelectNodes("creditDerivativesNotices");
     if (creditDerivativesNoticesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditDerivativesNoticesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditDerivativesNoticesIDRef = item.Attributes["id"].Name;
                 CreditDerivativesNotices ob = CreditDerivativesNotices();
                 IDManager.SetID(creditDerivativesNoticesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditDerivativesNoticesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditDerivativesNotices = new CreditDerivativesNotices(item);
             }
         }
     }
     
 
     XmlNodeList contractualDefinitionsNodeList = xmlNode.SelectNodes("contractualDefinitions");
     
     foreach (XmlNode item in contractualDefinitionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 contractualDefinitionsIDRef = item.Attributes["id"].Name;
                 List<ContractualDefinitions> ob = new List<ContractualDefinitions>();
                 ob.Add(new ContractualDefinitions(item));
                 IDManager.SetID(contractualDefinitionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 contractualDefinitionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
             contractualDefinitions.Add(new ContractualDefinitions(item));
             }
         }
     }
     
 
     XmlNodeList contractualTermsSupplementNodeList = xmlNode.SelectNodes("contractualTermsSupplement");
     
     foreach (XmlNode item in contractualTermsSupplementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 contractualTermsSupplementIDRef = item.Attributes["id"].Name;
                 List<ContractualTermsSupplement> ob = new List<ContractualTermsSupplement>();
                 ob.Add(new ContractualTermsSupplement(item));
                 IDManager.SetID(contractualTermsSupplementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 contractualTermsSupplementIDRef = item.Attributes["href"].Name;
             }
             else
             {
             contractualTermsSupplement.Add(new ContractualTermsSupplement(item));
             }
         }
     }
     
 
     XmlNodeList paymentNodeList = xmlNode.SelectNodes("payment");
     if (paymentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentIDRef = item.Attributes["id"].Name;
                 Payment ob = Payment();
                 IDManager.SetID(paymentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 payment = new Payment(item);
             }
         }
     }
     
 
 }
 public FxSingleLeg(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList exchangedCurrency1NodeList = xmlNode.SelectNodes("exchangedCurrency1");
     if (exchangedCurrency1NodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangedCurrency1NodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangedCurrency1IDRef = item.Attributes["id"].Name;
                 Payment ob = Payment();
                 IDManager.SetID(exchangedCurrency1IDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangedCurrency1IDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangedCurrency1 = new Payment(item);
             }
         }
     }
     
 
     XmlNodeList exchangedCurrency2NodeList = xmlNode.SelectNodes("exchangedCurrency2");
     if (exchangedCurrency2NodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangedCurrency2NodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangedCurrency2IDRef = item.Attributes["id"].Name;
                 Payment ob = Payment();
                 IDManager.SetID(exchangedCurrency2IDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangedCurrency2IDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangedCurrency2 = new Payment(item);
             }
         }
     }
     
 
     XmlNodeList dealtCurrencyNodeList = xmlNode.SelectNodes("dealtCurrency");
     if (dealtCurrencyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dealtCurrencyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dealtCurrencyIDRef = item.Attributes["id"].Name;
                 DealtCurrencyEnum ob = DealtCurrencyEnum();
                 IDManager.SetID(dealtCurrencyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dealtCurrencyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dealtCurrency = new DealtCurrencyEnum(item);
             }
         }
     }
     
 
     XmlNodeList tenorNameNodeList = xmlNode.SelectNodes("tenorName");
     if (tenorNameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tenorNameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tenorNameIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(tenorNameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tenorNameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tenorName = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList tenorPeriodNodeList = xmlNode.SelectNodes("tenorPeriod");
     if (tenorPeriodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tenorPeriodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tenorPeriodIDRef = item.Attributes["id"].Name;
                 Period ob = Period();
                 IDManager.SetID(tenorPeriodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tenorPeriodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tenorPeriod = new Period(item);
             }
         }
     }
     
 
     XmlNodeList valueDateNodeList = xmlNode.SelectNodes("valueDate");
     if (valueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(valueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList currency1ValueDateNodeList = xmlNode.SelectNodes("currency1ValueDate");
     if (currency1ValueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currency1ValueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currency1ValueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(currency1ValueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currency1ValueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currency1ValueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList currency2ValueDateNodeList = xmlNode.SelectNodes("currency2ValueDate");
     if (currency2ValueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in currency2ValueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 currency2ValueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(currency2ValueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 currency2ValueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 currency2ValueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList exchangeRateNodeList = xmlNode.SelectNodes("exchangeRate");
     if (exchangeRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exchangeRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exchangeRateIDRef = item.Attributes["id"].Name;
                 ExchangeRate ob = ExchangeRate();
                 IDManager.SetID(exchangeRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exchangeRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exchangeRate = new ExchangeRate(item);
             }
         }
     }
     
 
     XmlNodeList nonDeliverableSettlementNodeList = xmlNode.SelectNodes("nonDeliverableSettlement");
     if (nonDeliverableSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nonDeliverableSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nonDeliverableSettlementIDRef = item.Attributes["id"].Name;
                 FxCashSettlement ob = FxCashSettlement();
                 IDManager.SetID(nonDeliverableSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nonDeliverableSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 nonDeliverableSettlement = new FxCashSettlement(item);
             }
         }
     }
     
 
 }
 public TermCurve(XmlNode xmlNode)
 {
     XmlNodeList interpolationMethodNodeList = xmlNode.SelectNodes("interpolationMethod");
     if (interpolationMethodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in interpolationMethodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 interpolationMethodIDRef = item.Attributes["id"].Name;
                 InterpolationMethod ob = InterpolationMethod();
                 IDManager.SetID(interpolationMethodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 interpolationMethodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 interpolationMethod = new InterpolationMethod(item);
             }
         }
     }
     
 
     XmlNodeList extrapolationPermittedNodeList = xmlNode.SelectNodes("extrapolationPermitted");
     if (extrapolationPermittedNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in extrapolationPermittedNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 extrapolationPermittedIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(extrapolationPermittedIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 extrapolationPermittedIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 extrapolationPermitted = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList pointNodeList = xmlNode.SelectNodes("point");
     
     foreach (XmlNode item in pointNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pointIDRef = item.Attributes["id"].Name;
                 List<TermPoint> ob = new List<TermPoint>();
                 ob.Add(new TermPoint(item));
                 IDManager.SetID(pointIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pointIDRef = item.Attributes["href"].Name;
             }
             else
             {
             point.Add(new TermPoint(item));
             }
         }
     }
     
 
 }
 public CommodityPhysicalExercise(XmlNode xmlNode)
 {
     XmlNodeList americanExerciseNodeList = xmlNode.SelectNodes("americanExercise");
     if (americanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in americanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 americanExerciseIDRef = item.Attributes["id"].Name;
                 CommodityPhysicalAmericanExercise ob = CommodityPhysicalAmericanExercise();
                 IDManager.SetID(americanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 americanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 americanExercise = new CommodityPhysicalAmericanExercise(item);
             }
         }
     }
     
 
     XmlNodeList europeanExerciseNodeList = xmlNode.SelectNodes("europeanExercise");
     if (europeanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in europeanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 europeanExerciseIDRef = item.Attributes["id"].Name;
                 CommodityPhysicalEuropeanExercise ob = CommodityPhysicalEuropeanExercise();
                 IDManager.SetID(europeanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 europeanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 europeanExercise = new CommodityPhysicalEuropeanExercise(item);
             }
         }
     }
     
 
     XmlNodeList automaticExerciseNodeList = xmlNode.SelectNodes("automaticExercise");
     if (automaticExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in automaticExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 automaticExerciseIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(automaticExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 automaticExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 automaticExercise = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList writtenConfirmationNodeList = xmlNode.SelectNodes("writtenConfirmation");
     if (writtenConfirmationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in writtenConfirmationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 writtenConfirmationIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(writtenConfirmationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 writtenConfirmationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 writtenConfirmation = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public IndexCalculation(XmlNode xmlNode)
 {
     XmlNodeList timeTypeNodeList = xmlNode.SelectNodes("timeType");
     if (timeTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in timeTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 timeTypeIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(timeTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 timeTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 timeType = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList returnNodeList = xmlNode.SelectNodes("return");
     if (returnNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in returnNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 returnIDRef = item.Attributes["id"].Name;
                 ReturnTran ob = ReturnTran();
                 IDManager.SetID(returnIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 returnIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 return = new ReturnTran(item);
             }
         }
     }
     
 
     XmlNodeList minimumNodeList = xmlNode.SelectNodes("minimum");
     if (minimumNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumIDRef = item.Attributes["id"].Name;
                 MinimumTran ob = MinimumTran();
                 IDManager.SetID(minimumIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimum = new MinimumTran(item);
             }
         }
     }
     
 
     XmlNodeList basketAverNodeList = xmlNode.SelectNodes("basketAver");
     if (basketAverNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in basketAverNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 basketAverIDRef = item.Attributes["id"].Name;
                 BasketAver ob = BasketAver();
                 IDManager.SetID(basketAverIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 basketAverIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 basketAver = new BasketAver(item);
             }
         }
     }
     
 
 }
 public ExerciseProcedure(XmlNode xmlNode)
 {
     XmlNodeList manualExerciseNodeList = xmlNode.SelectNodes("manualExercise");
     if (manualExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in manualExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 manualExerciseIDRef = item.Attributes["id"].Name;
                 ManualExercise ob = ManualExercise();
                 IDManager.SetID(manualExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 manualExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 manualExercise = new ManualExercise(item);
             }
         }
     }
     
 
     XmlNodeList automaticExerciseNodeList = xmlNode.SelectNodes("automaticExercise");
     if (automaticExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in automaticExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 automaticExerciseIDRef = item.Attributes["id"].Name;
                 AutomaticExercise ob = AutomaticExercise();
                 IDManager.SetID(automaticExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 automaticExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 automaticExercise = new AutomaticExercise(item);
             }
         }
     }
     
 
     XmlNodeList followUpConfirmationNodeList = xmlNode.SelectNodes("followUpConfirmation");
     if (followUpConfirmationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in followUpConfirmationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 followUpConfirmationIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(followUpConfirmationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 followUpConfirmationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 followUpConfirmation = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList limitedRightToConfirmNodeList = xmlNode.SelectNodes("limitedRightToConfirm");
     if (limitedRightToConfirmNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in limitedRightToConfirmNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 limitedRightToConfirmIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(limitedRightToConfirmIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 limitedRightToConfirmIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 limitedRightToConfirm = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList splitTicketNodeList = xmlNode.SelectNodes("splitTicket");
     if (splitTicketNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in splitTicketNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 splitTicketIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(splitTicketIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 splitTicketIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 splitTicket = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public ReportingRegime(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;
                 ReportingRegimeName ob = ReportingRegimeName();
                 IDManager.SetID(nameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 name = new ReportingRegimeName(item);
             }
         }
     }
     
 
     XmlNodeList supervisorRegistrationNodeList = xmlNode.SelectNodes("supervisorRegistration");
     
     foreach (XmlNode item in supervisorRegistrationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 supervisorRegistrationIDRef = item.Attributes["id"].Name;
                 List<SupervisorRegistration> ob = new List<SupervisorRegistration>();
                 ob.Add(new SupervisorRegistration(item));
                 IDManager.SetID(supervisorRegistrationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 supervisorRegistrationIDRef = item.Attributes["href"].Name;
             }
             else
             {
             supervisorRegistration.Add(new SupervisorRegistration(item));
             }
         }
     }
     
 
     XmlNodeList reportingRoleNodeList = xmlNode.SelectNodes("reportingRole");
     if (reportingRoleNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in reportingRoleNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 reportingRoleIDRef = item.Attributes["id"].Name;
                 ReportingRole ob = ReportingRole();
                 IDManager.SetID(reportingRoleIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 reportingRoleIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 reportingRole = new ReportingRole(item);
             }
         }
     }
     
 
     XmlNodeList reportingPurposeNodeList = xmlNode.SelectNodes("reportingPurpose");
     
     foreach (XmlNode item in reportingPurposeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 reportingPurposeIDRef = item.Attributes["id"].Name;
                 List<ReportingPurpose> ob = new List<ReportingPurpose>();
                 ob.Add(new ReportingPurpose(item));
                 IDManager.SetID(reportingPurposeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 reportingPurposeIDRef = item.Attributes["href"].Name;
             }
             else
             {
             reportingPurpose.Add(new ReportingPurpose(item));
             }
         }
     }
     
 
     XmlNodeList mandatorilyClearableNodeList = xmlNode.SelectNodes("mandatorilyClearable");
     if (mandatorilyClearableNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mandatorilyClearableNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mandatorilyClearableIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(mandatorilyClearableIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mandatorilyClearableIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mandatorilyClearable = new XsdTypeBoolean(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);
             }
         }
     }
     
 
 }