{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
module Data.FpML.V53.Enum
  ( module Data.FpML.V53.Enum
  ) where
 
import Text.XML.HaXml.Schema.Schema (SchemaType(..),SimpleType(..),Extension(..),Restricts(..))
import Text.XML.HaXml.Schema.Schema as Schema
import Text.XML.HaXml.OneOfN
import qualified Text.XML.HaXml.Schema.PrimitiveTypes as Xsd
 
-- Some hs-boot imports are required, for fwd-declaring types.
 
-- | The type of averaging used in an Asian option.
data AveragingInOutEnum
    = AveragingInOutEnum_In
      -- ^ The average price is used to derive the strike price. Also 
      --   known as "Asian strike" style option.
    | AveragingInOutEnum_Out
      -- ^ The average price is used to derive the expiration price. 
      --   Also known as "Asian price" style option.
    | AveragingInOutEnum_Both
      -- ^ The average price is used to derive both the strike and the 
      --   expiration price.
    deriving (Eq,Show,Enum)
instance SchemaType AveragingInOutEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType AveragingInOutEnum where
    acceptingParser =  do isWord "In"; return AveragingInOutEnum_In
                      `onFail` do isWord "Out"; return AveragingInOutEnum_Out
                      `onFail` do isWord "Both"; return AveragingInOutEnum_Both
                      
    simpleTypeText AveragingInOutEnum_In = "In"
    simpleTypeText AveragingInOutEnum_Out = "Out"
    simpleTypeText AveragingInOutEnum_Both = "Both"
 
-- | The method of calculation to be used when averaging rates. 
--   Per ISDA 2000 Definitions, Section 6.2. Certain Definitions 
--   Relating to Floating Amounts.
data AveragingMethodEnum
    = AveragingMethodEnum_Unweighted
      -- ^ The arithmetic mean of the relevant rates for each reset 
      --   date.
    | AveragingMethodEnum_Weighted
      -- ^ The arithmetic mean of the relevant rates in effect for 
      --   each day in a calculation period calculated by multiplying 
      --   each relevant rate by the number of days such relevant rate 
      --   is in effect, determining the sum of such products and 
      --   dividing such sum by the number of days in the calculation 
      --   period.
    deriving (Eq,Show,Enum)
instance SchemaType AveragingMethodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType AveragingMethodEnum where
    acceptingParser =  do isWord "Unweighted"; return AveragingMethodEnum_Unweighted
                      `onFail` do isWord "Weighted"; return AveragingMethodEnum_Weighted
                      
    simpleTypeText AveragingMethodEnum_Unweighted = "Unweighted"
    simpleTypeText AveragingMethodEnum_Weighted = "Weighted"
 
-- | When breakage cost is applicable, defines who is 
--   calculating it.
data BreakageCostEnum
    = BreakageCostEnum_AgentBank
      -- ^ Breakage cost is calculated by the agent bank.
    | BreakageCostEnum_Lender
      -- ^ Breakage cost is calculated by the lender.
    deriving (Eq,Show,Enum)
instance SchemaType BreakageCostEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType BreakageCostEnum where
    acceptingParser =  do isWord "AgentBank"; return BreakageCostEnum_AgentBank
                      `onFail` do isWord "Lender"; return BreakageCostEnum_Lender
                      
    simpleTypeText BreakageCostEnum_AgentBank = "AgentBank"
    simpleTypeText BreakageCostEnum_Lender = "Lender"
 
-- | Defines which type of bullion is applicable for a Bullion 
--   Transaction.
data BullionTypeEnum
    = BullionTypeEnum_Gold
      -- ^ Gold. Quality as per the Good Delivery Rules issued by the 
      --   London Bullion Market Association.
    | BullionTypeEnum_Palladium
      -- ^ Palladium. Quality as per the Good Delivery Rules issued by 
      --   the London Platinum and Palladium Market.
    | BullionTypeEnum_Platinum
      -- ^ Palladium. Quality as per the Good Delivery Rules issued by 
      --   the London Platinum and Palladium Market.
    | BullionTypeEnum_Silver
      -- ^ Silver. Quality as per the Good Delivery Rules issued by 
      --   the London Bullion Market Association.
    | BullionTypeEnum_RhodiumSponge
      -- ^ Quality as per the Good Delivery Rules for Rhodium 
      --   (Sponge).
    deriving (Eq,Show,Enum)
instance SchemaType BullionTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType BullionTypeEnum where
    acceptingParser =  do isWord "Gold"; return BullionTypeEnum_Gold
                      `onFail` do isWord "Palladium"; return BullionTypeEnum_Palladium
                      `onFail` do isWord "Platinum"; return BullionTypeEnum_Platinum
                      `onFail` do isWord "Silver"; return BullionTypeEnum_Silver
                      `onFail` do isWord "RhodiumSponge"; return BullionTypeEnum_RhodiumSponge
                      
    simpleTypeText BullionTypeEnum_Gold = "Gold"
    simpleTypeText BullionTypeEnum_Palladium = "Palladium"
    simpleTypeText BullionTypeEnum_Platinum = "Platinum"
    simpleTypeText BullionTypeEnum_Silver = "Silver"
    simpleTypeText BullionTypeEnum_RhodiumSponge = "RhodiumSponge"
 
-- | The convention for adjusting any relevant date if it would 
--   otherwise fall on a day that is not a valid business day. 
--   Note that FRN is included here as a type of business day 
--   convention although it does not strictly fall within ISDA's 
--   definition of a Business Day Convention and does not 
--   conform to the simple definition given above.
data BusinessDayConventionEnum
    = BusinessDayConventionEnum_FOLLOWING
      -- ^ The non-business date will be adjusted to the first 
      --   following day that is a business day
    | BusinessDayConventionEnum_FRN
      -- ^ Per 2000 ISDA Definitions, Section 4.11. FRN Convention; 
      --   Eurodollar Convention.
    | BusinessDayConventionEnum_MODFOLLOWING
      -- ^ The non-business date will be adjusted to the first 
      --   following day that is a business day unless that day falls 
      --   in the next calendar month, in which case that date will be 
      --   the first preceding day that is a business day.
    | BusinessDayConventionEnum_PRECEDING
      -- ^ The non-business day will be adjusted to the first 
      --   preceding day that is a business day.
    | BusinessDayConventionEnum_MODPRECEDING
      -- ^ The non-business date will be adjusted to the first 
      --   preceding day that is a business day unless that day falls 
      --   in the previous calendar month, in which case that date 
      --   will be the first following day that us a business day.
    | BusinessDayConventionEnum_NEAREST
      -- ^ The non-business date will be adjusted to the nearest day 
      --   that is a business day - i.e. if the non-business day falls 
      --   on any day other than a Sunday or a Monday, it will be the 
      --   first preceding day that is a business day, and will be the 
      --   first following business day if it falls on a Sunday or a 
      --   Monday.
    | BusinessDayConventionEnum_NONE
      -- ^ The date will not be adjusted if it falls on a day that is 
      --   not a business day.
    | BusinessDayConventionEnum_NotApplicable
      -- ^ The date adjustments conventions are defined elsewhere, so 
      --   it is not required to specify them here.
    deriving (Eq,Show,Enum)
instance SchemaType BusinessDayConventionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType BusinessDayConventionEnum where
    acceptingParser =  do isWord "FOLLOWING"; return BusinessDayConventionEnum_FOLLOWING
                      `onFail` do isWord "FRN"; return BusinessDayConventionEnum_FRN
                      `onFail` do isWord "MODFOLLOWING"; return BusinessDayConventionEnum_MODFOLLOWING
                      `onFail` do isWord "PRECEDING"; return BusinessDayConventionEnum_PRECEDING
                      `onFail` do isWord "MODPRECEDING"; return BusinessDayConventionEnum_MODPRECEDING
                      `onFail` do isWord "NEAREST"; return BusinessDayConventionEnum_NEAREST
                      `onFail` do isWord "NONE"; return BusinessDayConventionEnum_NONE
                      `onFail` do isWord "NotApplicable"; return BusinessDayConventionEnum_NotApplicable
                      
    simpleTypeText BusinessDayConventionEnum_FOLLOWING = "FOLLOWING"
    simpleTypeText BusinessDayConventionEnum_FRN = "FRN"
    simpleTypeText BusinessDayConventionEnum_MODFOLLOWING = "MODFOLLOWING"
    simpleTypeText BusinessDayConventionEnum_PRECEDING = "PRECEDING"
    simpleTypeText BusinessDayConventionEnum_MODPRECEDING = "MODPRECEDING"
    simpleTypeText BusinessDayConventionEnum_NEAREST = "NEAREST"
    simpleTypeText BusinessDayConventionEnum_NONE = "NONE"
    simpleTypeText BusinessDayConventionEnum_NotApplicable = "NotApplicable"
 
-- | Shows how the transaction is to be settled when it is 
--   exercised.
data CashPhysicalEnum
    = CashPhysicalEnum_Cash
      -- ^ The intrinsic value of the option will be delivered by way 
      --   of a cash settlement amount determined, (i) by reference to 
      --   the differential between the strike price and the 
      --   settlement price; or (ii) in accordance with a bilateral 
      --   agreement between the parties
    | CashPhysicalEnum_Physical
      -- ^ The securities underlying the transaction will be delivered 
      --   by (i) in the case of a call, the seller to the buyer, or 
      --   (ii) in the case of a put, the buyer to the seller versus a 
      --   settlement amount equivalent to the strike price per share
    deriving (Eq,Show,Enum)
instance SchemaType CashPhysicalEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType CashPhysicalEnum where
    acceptingParser =  do isWord "Cash"; return CashPhysicalEnum_Cash
                      `onFail` do isWord "Physical"; return CashPhysicalEnum_Physical
                      
    simpleTypeText CashPhysicalEnum_Cash = "Cash"
    simpleTypeText CashPhysicalEnum_Physical = "Physical"
 
-- | The specification of how a calculation agent will be 
--   determined.
data CalculationAgentPartyEnum
    = CalculationAgentPartyEnum_ExercisingParty
      -- ^ The party that gives notice of exercise. Per 2000 ISDA 
      --   Definitions, Section 11.1. Parties, paragraph (d).
    | CalculationAgentPartyEnum_NonExercisingParty
      -- ^ The party that is given notice of exercise. Per 2000 ISDA 
      --   Definitions, Section 11.1. Parties, paragraph (e).
    | CalculationAgentPartyEnum_AsSpecifiedInMasterAgreement
      -- ^ The Calculation Agent is determined by reference to the 
      --   relevant master agreement.
    | CalculationAgentPartyEnum_AsSpecifiedInStandardTermsSupplement
      -- ^ The Calculation Agent is determined by reference to the 
      --   relevant standard terms supplement.
    deriving (Eq,Show,Enum)
instance SchemaType CalculationAgentPartyEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType CalculationAgentPartyEnum where
    acceptingParser =  do isWord "ExercisingParty"; return CalculationAgentPartyEnum_ExercisingParty
                      `onFail` do isWord "NonExercisingParty"; return CalculationAgentPartyEnum_NonExercisingParty
                      `onFail` do isWord "AsSpecifiedInMasterAgreement"; return CalculationAgentPartyEnum_AsSpecifiedInMasterAgreement
                      `onFail` do isWord "AsSpecifiedInStandardTermsSupplement"; return CalculationAgentPartyEnum_AsSpecifiedInStandardTermsSupplement
                      
    simpleTypeText CalculationAgentPartyEnum_ExercisingParty = "ExercisingParty"
    simpleTypeText CalculationAgentPartyEnum_NonExercisingParty = "NonExercisingParty"
    simpleTypeText CalculationAgentPartyEnum_AsSpecifiedInMasterAgreement = "AsSpecifiedInMasterAgreement"
    simpleTypeText CalculationAgentPartyEnum_AsSpecifiedInStandardTermsSupplement = "AsSpecifiedInStandardTermsSupplement"
 
-- | The unit in which a commission is denominated.
data CommissionDenominationEnum
    = CommissionDenominationEnum_BPS
      -- ^ The commission is expressed in basis points, in reference 
      --   to the price referenced in the document.
    | CommissionDenominationEnum_Percentage
      -- ^ The commission is expressed as a percentage of the gross 
      --   price referenced in the document.
    | CommissionDenominationEnum_CentsPerShare
      -- ^ The commission is expressed in cents per share.
    | CommissionDenominationEnum_FixedAmount
      -- ^ The commission is expressed as a absolute amount.
    deriving (Eq,Show,Enum)
instance SchemaType CommissionDenominationEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType CommissionDenominationEnum where
    acceptingParser =  do isWord "BPS"; return CommissionDenominationEnum_BPS
                      `onFail` do isWord "Percentage"; return CommissionDenominationEnum_Percentage
                      `onFail` do isWord "CentsPerShare"; return CommissionDenominationEnum_CentsPerShare
                      `onFail` do isWord "FixedAmount"; return CommissionDenominationEnum_FixedAmount
                      
    simpleTypeText CommissionDenominationEnum_BPS = "BPS"
    simpleTypeText CommissionDenominationEnum_Percentage = "Percentage"
    simpleTypeText CommissionDenominationEnum_CentsPerShare = "CentsPerShare"
    simpleTypeText CommissionDenominationEnum_FixedAmount = "FixedAmount"
 
-- | The consequences of Bullion Settlement Disruption Events.
data CommodityBullionSettlementDisruptionEnum
    = CommodityBullionSettlementDisruptionEnum_Negotiation
      -- ^ Negotiation will apply in the event of Bullion Settlement 
      --   Disruption as per Section 10.5.(d) of the 2005 Commodity 
      --   Definitions.
    | CommodityBullionSettlementDisruptionEnum_CancellationandPayment
      -- ^ Cancellation and Payment will apply in the event of Bullion 
      --   Settlement Disruption as per Section 10.5.(d) of the 2005 
      --   Commodity Definitions.
    deriving (Eq,Show,Enum)
instance SchemaType CommodityBullionSettlementDisruptionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType CommodityBullionSettlementDisruptionEnum where
    acceptingParser =  do isWord "Negotiation"; return CommodityBullionSettlementDisruptionEnum_Negotiation
                      `onFail` do isWord "CancellationandPayment"; return CommodityBullionSettlementDisruptionEnum_CancellationandPayment
                      
    simpleTypeText CommodityBullionSettlementDisruptionEnum_Negotiation = "Negotiation"
    simpleTypeText CommodityBullionSettlementDisruptionEnum_CancellationandPayment = "CancellationandPayment"
 
-- | A day type classification used in counting the number of 
--   days between two dates for a commodity transaction.
data CommodityDayTypeEnum
    = CommodityDayTypeEnum_Business
      -- ^ When calculating the number of days between two dates the 
      --   count includes only business days.
    | CommodityDayTypeEnum_Calendar
      -- ^ When calculating the number of days between two dates the 
      --   count includes all calendar days.
    | CommodityDayTypeEnum_CommodityBusiness
      -- ^ When calculating the number of days between two dates the 
      --   count includes only commodity business days.
    | CommodityDayTypeEnum_CurrencyBusiness
      -- ^ When calculating the number of days between two dates the 
      --   count includes only currency business days.
    | CommodityDayTypeEnum_ExchangeBusiness
      -- ^ When calculating the number of days between two dates the 
      --   count includes only stock exchange business days.
    | CommodityDayTypeEnum_ScheduledTradingDay
      -- ^ When calculating the number of days between two dates the 
      --   count includes only scheduled trading days.
    | CommodityDayTypeEnum_GasFlow
      -- ^ When calculating the number of days between two dates the 
      --   count includes only gas flow days (dates on which gas is 
      --   delivered).
    deriving (Eq,Show,Enum)
instance SchemaType CommodityDayTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType CommodityDayTypeEnum where
    acceptingParser =  do isWord "Business"; return CommodityDayTypeEnum_Business
                      `onFail` do isWord "Calendar"; return CommodityDayTypeEnum_Calendar
                      `onFail` do isWord "CommodityBusiness"; return CommodityDayTypeEnum_CommodityBusiness
                      `onFail` do isWord "CurrencyBusiness"; return CommodityDayTypeEnum_CurrencyBusiness
                      `onFail` do isWord "ExchangeBusiness"; return CommodityDayTypeEnum_ExchangeBusiness
                      `onFail` do isWord "ScheduledTradingDay"; return CommodityDayTypeEnum_ScheduledTradingDay
                      `onFail` do isWord "GasFlow"; return CommodityDayTypeEnum_GasFlow
                      
    simpleTypeText CommodityDayTypeEnum_Business = "Business"
    simpleTypeText CommodityDayTypeEnum_Calendar = "Calendar"
    simpleTypeText CommodityDayTypeEnum_CommodityBusiness = "CommodityBusiness"
    simpleTypeText CommodityDayTypeEnum_CurrencyBusiness = "CurrencyBusiness"
    simpleTypeText CommodityDayTypeEnum_ExchangeBusiness = "ExchangeBusiness"
    simpleTypeText CommodityDayTypeEnum_ScheduledTradingDay = "ScheduledTradingDay"
    simpleTypeText CommodityDayTypeEnum_GasFlow = "GasFlow"
 
-- | The compounding calculation method
data CompoundingMethodEnum
    = CompoundingMethodEnum_Flat
      -- ^ Flat compounding. Compounding excludes the spread. Note 
      --   that the first compounding period has it's interest 
      --   calculated including any spread then subsequent periods 
      --   compound this at a rate excluding the spread.
    | CompoundingMethodEnum_None
      -- ^ No compounding is to be applied.
    | CompoundingMethodEnum_Straight
      -- ^ Straight compounding. Compounding includes the spread.
    | CompoundingMethodEnum_SpreadExclusive
      -- ^ Spread Exclusive compounding.
    deriving (Eq,Show,Enum)
instance SchemaType CompoundingMethodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType CompoundingMethodEnum where
    acceptingParser =  do isWord "Flat"; return CompoundingMethodEnum_Flat
                      `onFail` do isWord "None"; return CompoundingMethodEnum_None
                      `onFail` do isWord "Straight"; return CompoundingMethodEnum_Straight
                      `onFail` do isWord "SpreadExclusive"; return CompoundingMethodEnum_SpreadExclusive
                      
    simpleTypeText CompoundingMethodEnum_Flat = "Flat"
    simpleTypeText CompoundingMethodEnum_None = "None"
    simpleTypeText CompoundingMethodEnum_Straight = "Straight"
    simpleTypeText CompoundingMethodEnum_SpreadExclusive = "SpreadExclusive"
 
-- | A day of the seven-day week.
data DayOfWeekEnum
    = DayOfWeekEnum_MON
      -- ^ Monday
    | DayOfWeekEnum_TUE
      -- ^ Tuesday
    | DayOfWeekEnum_WED
      -- ^ Wednesday
    | DayOfWeekEnum_THU
      -- ^ Thursday
    | DayOfWeekEnum_FRI
      -- ^ Friday
    | DayOfWeekEnum_SAT
      -- ^ Saturday
    | DayOfWeekEnum_SUN
      -- ^ Sunday
    deriving (Eq,Show,Enum)
instance SchemaType DayOfWeekEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DayOfWeekEnum where
    acceptingParser =  do isWord "MON"; return DayOfWeekEnum_MON
                      `onFail` do isWord "TUE"; return DayOfWeekEnum_TUE
                      `onFail` do isWord "WED"; return DayOfWeekEnum_WED
                      `onFail` do isWord "THU"; return DayOfWeekEnum_THU
                      `onFail` do isWord "FRI"; return DayOfWeekEnum_FRI
                      `onFail` do isWord "SAT"; return DayOfWeekEnum_SAT
                      `onFail` do isWord "SUN"; return DayOfWeekEnum_SUN
                      
    simpleTypeText DayOfWeekEnum_MON = "MON"
    simpleTypeText DayOfWeekEnum_TUE = "TUE"
    simpleTypeText DayOfWeekEnum_WED = "WED"
    simpleTypeText DayOfWeekEnum_THU = "THU"
    simpleTypeText DayOfWeekEnum_FRI = "FRI"
    simpleTypeText DayOfWeekEnum_SAT = "SAT"
    simpleTypeText DayOfWeekEnum_SUN = "SUN"
 
-- | A day type classification used in counting the number of 
--   days between two dates.
data DayTypeEnum
    = DayTypeEnum_Business
      -- ^ When calculating the number of days between two dates the 
      --   count includes only business days.
    | DayTypeEnum_Calendar
      -- ^ When calculating the number of days between two dates the 
      --   count includes all calendar days.
    | DayTypeEnum_CommodityBusiness
      -- ^ When calculating the number of days between two dates the 
      --   count includes only commodity business days.
    | DayTypeEnum_CurrencyBusiness
      -- ^ When calculating the number of days between two dates the 
      --   count includes only currency business days.
    | DayTypeEnum_ExchangeBusiness
      -- ^ When calculating the number of days between two dates the 
      --   count includes only stock exchange business days.
    | DayTypeEnum_ScheduledTradingDay
      -- ^ When calculating the number of days between two dates the 
      --   count includes only scheduled trading days.
    deriving (Eq,Show,Enum)
instance SchemaType DayTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DayTypeEnum where
    acceptingParser =  do isWord "Business"; return DayTypeEnum_Business
                      `onFail` do isWord "Calendar"; return DayTypeEnum_Calendar
                      `onFail` do isWord "CommodityBusiness"; return DayTypeEnum_CommodityBusiness
                      `onFail` do isWord "CurrencyBusiness"; return DayTypeEnum_CurrencyBusiness
                      `onFail` do isWord "ExchangeBusiness"; return DayTypeEnum_ExchangeBusiness
                      `onFail` do isWord "ScheduledTradingDay"; return DayTypeEnum_ScheduledTradingDay
                      
    simpleTypeText DayTypeEnum_Business = "Business"
    simpleTypeText DayTypeEnum_Calendar = "Calendar"
    simpleTypeText DayTypeEnum_CommodityBusiness = "CommodityBusiness"
    simpleTypeText DayTypeEnum_CurrencyBusiness = "CurrencyBusiness"
    simpleTypeText DayTypeEnum_ExchangeBusiness = "ExchangeBusiness"
    simpleTypeText DayTypeEnum_ScheduledTradingDay = "ScheduledTradingDay"
 
data DealtCurrencyEnum
    = DealtCurrencyEnum_ExchangedCurrency1
    | DealtCurrencyEnum_ExchangedCurrency2
    deriving (Eq,Show,Enum)
instance SchemaType DealtCurrencyEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DealtCurrencyEnum where
    acceptingParser =  do isWord "ExchangedCurrency1"; return DealtCurrencyEnum_ExchangedCurrency1
                      `onFail` do isWord "ExchangedCurrency2"; return DealtCurrencyEnum_ExchangedCurrency2
                      
    simpleTypeText DealtCurrencyEnum_ExchangedCurrency1 = "ExchangedCurrency1"
    simpleTypeText DealtCurrencyEnum_ExchangedCurrency2 = "ExchangedCurrency2"
 
-- | In respect of a Transaction and a Commodity Reference 
--   Price, the relevant date or month for delivery of the 
--   underlying Commodity.
data DeliveryDatesEnum
    = DeliveryDatesEnum_CalculationPeriod
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the futures contract that 
      --   corresponds to the month and year of the Calculation 
      --   Period. e.g. The JAN 09 contract when pricing in January 
      --   '09 (In the case of contracts like Brent crude, this will 
      --   mean that the contract expired in DEC 08.)
    | DeliveryDatesEnum_FirstNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the First Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_SecondNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Second Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_ThirdNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Third Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_FourthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Fourth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_FifthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Fifth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_SixthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Sixth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_SeventhNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Seventh Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_EighthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Eighth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_NinthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Ninth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_TenthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Tenth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_EleventhNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Eleventh Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_TwelfthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Twelfth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_ThirteenthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Thirteenth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_FourteenthNearby
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   month of expiration of the Fourteenth Nearby Month futures 
      --   contract.
    | DeliveryDatesEnum_Spot
      -- ^ The Delivery Date of the underlying Commodity shall be the 
      --   Spot date.
    | DeliveryDatesEnum_V1stNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the First Nearby Week.
    | DeliveryDatesEnum_V2ndNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Second Nearby Week.
    | DeliveryDatesEnum_V3rdNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Third Nearby Week.
    | DeliveryDatesEnum_V4thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Fourth Nearby Week.
    | DeliveryDatesEnum_V5thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Fifth Nearby Week.
    | DeliveryDatesEnum_V6thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Sixth Nearby Week.
    | DeliveryDatesEnum_V7thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Seventh Nearby Week.
    | DeliveryDatesEnum_V8thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Eighth Nearby Week.
    | DeliveryDatesEnum_V9thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Ninth Nearby Week.
    | DeliveryDatesEnum_V10thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Tenth Nearby Week.
    | DeliveryDatesEnum_V11thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Eleventh Nearby Week.
    | DeliveryDatesEnum_V12thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twelfth Nearby Week.
    | DeliveryDatesEnum_V13thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirteenth Nearby Week.
    | DeliveryDatesEnum_V14thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Fourteenth Nearby Week.
    | DeliveryDatesEnum_V15thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Fifteenth Nearby Week.
    | DeliveryDatesEnum_V16thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Sixteenth Nearby Week.
    | DeliveryDatesEnum_V17thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Seventeenth Nearby Week.
    | DeliveryDatesEnum_V18thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Eighteenth Nearby Week.
    | DeliveryDatesEnum_V19thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Nineteenth Nearby Week.
    | DeliveryDatesEnum_V20thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twentieth Nearby Week.
    | DeliveryDatesEnum_V21stNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty First Nearby Week.
    | DeliveryDatesEnum_V22ndNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty Second Nearby Week.
    | DeliveryDatesEnum_V23rdNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty Third Nearby Week.
    | DeliveryDatesEnum_V24thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty Fourth Nearby Week.
    | DeliveryDatesEnum_V25thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty Fifth Nearby Week.
    | DeliveryDatesEnum_V26thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty Sixth Nearby Week.
    | DeliveryDatesEnum_V27thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty Seventh Nearby Week.
    | DeliveryDatesEnum_V28thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty Eighth Nearby Week.
    | DeliveryDatesEnum_V29thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Twenty Ninth Nearby Week.
    | DeliveryDatesEnum_V30thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirtieth Nearby Week.
    | DeliveryDatesEnum_V31stNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty First Nearby Week.
    | DeliveryDatesEnum_V32ndNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty Second Nearby Week.
    | DeliveryDatesEnum_V33rdNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty Third Nearby Week.
    | DeliveryDatesEnum_V34thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty Fourth Nearby Week.
    | DeliveryDatesEnum_V35thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty Fifth Nearby Week.
    | DeliveryDatesEnum_V36thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty Sixth Nearby Week.
    | DeliveryDatesEnum_V37thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty Seventh Nearby Week.
    | DeliveryDatesEnum_V38thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty Eighth Nearby Week.
    | DeliveryDatesEnum_V39thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Thirty Ninth Nearby Week.
    | DeliveryDatesEnum_V40thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Fortieth Nearby Week.
    | DeliveryDatesEnum_V41stNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty First Nearby Week.
    | DeliveryDatesEnum_V42ndNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty Second Nearby Week.
    | DeliveryDatesEnum_V43rdNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty Third Nearby Week.
    | DeliveryDatesEnum_V44thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty Fourth Nearby Week.
    | DeliveryDatesEnum_V45thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty Fifth Nearby Week.
    | DeliveryDatesEnum_V46thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty Sixth Nearby Week.
    | DeliveryDatesEnum_V47thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty Seventh Nearby Week.
    | DeliveryDatesEnum_V48thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty Eighth Nearby Week.
    | DeliveryDatesEnum_V49thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Forty Ninth Nearby Week.
    | DeliveryDatesEnum_V50thNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Fiftieth Nearby Week.
    | DeliveryDatesEnum_V51stNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Fifty First Nearby Week.
    | DeliveryDatesEnum_V52ndNearbyWeek
      -- ^ The Delivery Date of the underlying Commodity shall be 
      --   during the Fifty Second Nearby Week.
    deriving (Eq,Show,Enum)
instance SchemaType DeliveryDatesEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DeliveryDatesEnum where
    acceptingParser =  do isWord "CalculationPeriod"; return DeliveryDatesEnum_CalculationPeriod
                      `onFail` do isWord "FirstNearby"; return DeliveryDatesEnum_FirstNearby
                      `onFail` do isWord "SecondNearby"; return DeliveryDatesEnum_SecondNearby
                      `onFail` do isWord "ThirdNearby"; return DeliveryDatesEnum_ThirdNearby
                      `onFail` do isWord "FourthNearby"; return DeliveryDatesEnum_FourthNearby
                      `onFail` do isWord "FifthNearby"; return DeliveryDatesEnum_FifthNearby
                      `onFail` do isWord "SixthNearby"; return DeliveryDatesEnum_SixthNearby
                      `onFail` do isWord "SeventhNearby"; return DeliveryDatesEnum_SeventhNearby
                      `onFail` do isWord "EighthNearby"; return DeliveryDatesEnum_EighthNearby
                      `onFail` do isWord "NinthNearby"; return DeliveryDatesEnum_NinthNearby
                      `onFail` do isWord "TenthNearby"; return DeliveryDatesEnum_TenthNearby
                      `onFail` do isWord "EleventhNearby"; return DeliveryDatesEnum_EleventhNearby
                      `onFail` do isWord "TwelfthNearby"; return DeliveryDatesEnum_TwelfthNearby
                      `onFail` do isWord "ThirteenthNearby"; return DeliveryDatesEnum_ThirteenthNearby
                      `onFail` do isWord "FourteenthNearby"; return DeliveryDatesEnum_FourteenthNearby
                      `onFail` do isWord "Spot"; return DeliveryDatesEnum_Spot
                      `onFail` do isWord "1stNearbyWeek"; return DeliveryDatesEnum_V1stNearbyWeek
                      `onFail` do isWord "2ndNearbyWeek"; return DeliveryDatesEnum_V2ndNearbyWeek
                      `onFail` do isWord "3rdNearbyWeek"; return DeliveryDatesEnum_V3rdNearbyWeek
                      `onFail` do isWord "4thNearbyWeek"; return DeliveryDatesEnum_V4thNearbyWeek
                      `onFail` do isWord "5thNearbyWeek"; return DeliveryDatesEnum_V5thNearbyWeek
                      `onFail` do isWord "6thNearbyWeek"; return DeliveryDatesEnum_V6thNearbyWeek
                      `onFail` do isWord "7thNearbyWeek"; return DeliveryDatesEnum_V7thNearbyWeek
                      `onFail` do isWord "8thNearbyWeek"; return DeliveryDatesEnum_V8thNearbyWeek
                      `onFail` do isWord "9thNearbyWeek"; return DeliveryDatesEnum_V9thNearbyWeek
                      `onFail` do isWord "10thNearbyWeek"; return DeliveryDatesEnum_V10thNearbyWeek
                      `onFail` do isWord "11thNearbyWeek"; return DeliveryDatesEnum_V11thNearbyWeek
                      `onFail` do isWord "12thNearbyWeek"; return DeliveryDatesEnum_V12thNearbyWeek
                      `onFail` do isWord "13thNearbyWeek"; return DeliveryDatesEnum_V13thNearbyWeek
                      `onFail` do isWord "14thNearbyWeek"; return DeliveryDatesEnum_V14thNearbyWeek
                      `onFail` do isWord "15thNearbyWeek"; return DeliveryDatesEnum_V15thNearbyWeek
                      `onFail` do isWord "16thNearbyWeek"; return DeliveryDatesEnum_V16thNearbyWeek
                      `onFail` do isWord "17thNearbyWeek"; return DeliveryDatesEnum_V17thNearbyWeek
                      `onFail` do isWord "18thNearbyWeek"; return DeliveryDatesEnum_V18thNearbyWeek
                      `onFail` do isWord "19thNearbyWeek"; return DeliveryDatesEnum_V19thNearbyWeek
                      `onFail` do isWord "20thNearbyWeek"; return DeliveryDatesEnum_V20thNearbyWeek
                      `onFail` do isWord "21stNearbyWeek"; return DeliveryDatesEnum_V21stNearbyWeek
                      `onFail` do isWord "22ndNearbyWeek"; return DeliveryDatesEnum_V22ndNearbyWeek
                      `onFail` do isWord "23rdNearbyWeek"; return DeliveryDatesEnum_V23rdNearbyWeek
                      `onFail` do isWord "24thNearbyWeek"; return DeliveryDatesEnum_V24thNearbyWeek
                      `onFail` do isWord "25thNearbyWeek"; return DeliveryDatesEnum_V25thNearbyWeek
                      `onFail` do isWord "26thNearbyWeek"; return DeliveryDatesEnum_V26thNearbyWeek
                      `onFail` do isWord "27thNearbyWeek"; return DeliveryDatesEnum_V27thNearbyWeek
                      `onFail` do isWord "28thNearbyWeek"; return DeliveryDatesEnum_V28thNearbyWeek
                      `onFail` do isWord "29thNearbyWeek"; return DeliveryDatesEnum_V29thNearbyWeek
                      `onFail` do isWord "30thNearbyWeek"; return DeliveryDatesEnum_V30thNearbyWeek
                      `onFail` do isWord "31stNearbyWeek"; return DeliveryDatesEnum_V31stNearbyWeek
                      `onFail` do isWord "32ndNearbyWeek"; return DeliveryDatesEnum_V32ndNearbyWeek
                      `onFail` do isWord "33rdNearbyWeek"; return DeliveryDatesEnum_V33rdNearbyWeek
                      `onFail` do isWord "34thNearbyWeek"; return DeliveryDatesEnum_V34thNearbyWeek
                      `onFail` do isWord "35thNearbyWeek"; return DeliveryDatesEnum_V35thNearbyWeek
                      `onFail` do isWord "36thNearbyWeek"; return DeliveryDatesEnum_V36thNearbyWeek
                      `onFail` do isWord "37thNearbyWeek"; return DeliveryDatesEnum_V37thNearbyWeek
                      `onFail` do isWord "38thNearbyWeek"; return DeliveryDatesEnum_V38thNearbyWeek
                      `onFail` do isWord "39thNearbyWeek"; return DeliveryDatesEnum_V39thNearbyWeek
                      `onFail` do isWord "40thNearbyWeek"; return DeliveryDatesEnum_V40thNearbyWeek
                      `onFail` do isWord "41stNearbyWeek"; return DeliveryDatesEnum_V41stNearbyWeek
                      `onFail` do isWord "42ndNearbyWeek"; return DeliveryDatesEnum_V42ndNearbyWeek
                      `onFail` do isWord "43rdNearbyWeek"; return DeliveryDatesEnum_V43rdNearbyWeek
                      `onFail` do isWord "44thNearbyWeek"; return DeliveryDatesEnum_V44thNearbyWeek
                      `onFail` do isWord "45thNearbyWeek"; return DeliveryDatesEnum_V45thNearbyWeek
                      `onFail` do isWord "46thNearbyWeek"; return DeliveryDatesEnum_V46thNearbyWeek
                      `onFail` do isWord "47thNearbyWeek"; return DeliveryDatesEnum_V47thNearbyWeek
                      `onFail` do isWord "48thNearbyWeek"; return DeliveryDatesEnum_V48thNearbyWeek
                      `onFail` do isWord "49thNearbyWeek"; return DeliveryDatesEnum_V49thNearbyWeek
                      `onFail` do isWord "50thNearbyWeek"; return DeliveryDatesEnum_V50thNearbyWeek
                      `onFail` do isWord "51stNearbyWeek"; return DeliveryDatesEnum_V51stNearbyWeek
                      `onFail` do isWord "52ndNearbyWeek"; return DeliveryDatesEnum_V52ndNearbyWeek
                      
    simpleTypeText DeliveryDatesEnum_CalculationPeriod = "CalculationPeriod"
    simpleTypeText DeliveryDatesEnum_FirstNearby = "FirstNearby"
    simpleTypeText DeliveryDatesEnum_SecondNearby = "SecondNearby"
    simpleTypeText DeliveryDatesEnum_ThirdNearby = "ThirdNearby"
    simpleTypeText DeliveryDatesEnum_FourthNearby = "FourthNearby"
    simpleTypeText DeliveryDatesEnum_FifthNearby = "FifthNearby"
    simpleTypeText DeliveryDatesEnum_SixthNearby = "SixthNearby"
    simpleTypeText DeliveryDatesEnum_SeventhNearby = "SeventhNearby"
    simpleTypeText DeliveryDatesEnum_EighthNearby = "EighthNearby"
    simpleTypeText DeliveryDatesEnum_NinthNearby = "NinthNearby"
    simpleTypeText DeliveryDatesEnum_TenthNearby = "TenthNearby"
    simpleTypeText DeliveryDatesEnum_EleventhNearby = "EleventhNearby"
    simpleTypeText DeliveryDatesEnum_TwelfthNearby = "TwelfthNearby"
    simpleTypeText DeliveryDatesEnum_ThirteenthNearby = "ThirteenthNearby"
    simpleTypeText DeliveryDatesEnum_FourteenthNearby = "FourteenthNearby"
    simpleTypeText DeliveryDatesEnum_Spot = "Spot"
    simpleTypeText DeliveryDatesEnum_V1stNearbyWeek = "1stNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V2ndNearbyWeek = "2ndNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V3rdNearbyWeek = "3rdNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V4thNearbyWeek = "4thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V5thNearbyWeek = "5thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V6thNearbyWeek = "6thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V7thNearbyWeek = "7thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V8thNearbyWeek = "8thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V9thNearbyWeek = "9thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V10thNearbyWeek = "10thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V11thNearbyWeek = "11thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V12thNearbyWeek = "12thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V13thNearbyWeek = "13thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V14thNearbyWeek = "14thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V15thNearbyWeek = "15thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V16thNearbyWeek = "16thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V17thNearbyWeek = "17thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V18thNearbyWeek = "18thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V19thNearbyWeek = "19thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V20thNearbyWeek = "20thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V21stNearbyWeek = "21stNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V22ndNearbyWeek = "22ndNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V23rdNearbyWeek = "23rdNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V24thNearbyWeek = "24thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V25thNearbyWeek = "25thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V26thNearbyWeek = "26thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V27thNearbyWeek = "27thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V28thNearbyWeek = "28thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V29thNearbyWeek = "29thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V30thNearbyWeek = "30thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V31stNearbyWeek = "31stNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V32ndNearbyWeek = "32ndNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V33rdNearbyWeek = "33rdNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V34thNearbyWeek = "34thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V35thNearbyWeek = "35thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V36thNearbyWeek = "36thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V37thNearbyWeek = "37thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V38thNearbyWeek = "38thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V39thNearbyWeek = "39thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V40thNearbyWeek = "40thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V41stNearbyWeek = "41stNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V42ndNearbyWeek = "42ndNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V43rdNearbyWeek = "43rdNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V44thNearbyWeek = "44thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V45thNearbyWeek = "45thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V46thNearbyWeek = "46thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V47thNearbyWeek = "47thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V48thNearbyWeek = "48thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V49thNearbyWeek = "49thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V50thNearbyWeek = "50thNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V51stNearbyWeek = "51stNearbyWeek"
    simpleTypeText DeliveryDatesEnum_V52ndNearbyWeek = "52ndNearbyWeek"
 
data DeliveryTypeEnum
    = DeliveryTypeEnum_Firm
    | DeliveryTypeEnum_Interruptible
    deriving (Eq,Show,Enum)
instance SchemaType DeliveryTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DeliveryTypeEnum where
    acceptingParser =  do isWord "Firm"; return DeliveryTypeEnum_Firm
                      `onFail` do isWord "Interruptible"; return DeliveryTypeEnum_Interruptible
                      
    simpleTypeText DeliveryTypeEnum_Firm = "Firm"
    simpleTypeText DeliveryTypeEnum_Interruptible = "Interruptible"
 
-- | The ISDA defined value indicating the severity of a 
--   difference.
data DifferenceSeverityEnum
    = DifferenceSeverityEnum_Warning
    | DifferenceSeverityEnum_Error
    deriving (Eq,Show,Enum)
instance SchemaType DifferenceSeverityEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DifferenceSeverityEnum where
    acceptingParser =  do isWord "Warning"; return DifferenceSeverityEnum_Warning
                      `onFail` do isWord "Error"; return DifferenceSeverityEnum_Error
                      
    simpleTypeText DifferenceSeverityEnum_Warning = "Warning"
    simpleTypeText DifferenceSeverityEnum_Error = "Error"
 
-- | The ISDA defined value indicating the nature of a 
--   difference.
data DifferenceTypeEnum
    = DifferenceTypeEnum_Value
    | DifferenceTypeEnum_Reference
    | DifferenceTypeEnum_Structure
    | DifferenceTypeEnum_Scheme
    deriving (Eq,Show,Enum)
instance SchemaType DifferenceTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DifferenceTypeEnum where
    acceptingParser =  do isWord "Value"; return DifferenceTypeEnum_Value
                      `onFail` do isWord "Reference"; return DifferenceTypeEnum_Reference
                      `onFail` do isWord "Structure"; return DifferenceTypeEnum_Structure
                      `onFail` do isWord "Scheme"; return DifferenceTypeEnum_Scheme
                      
    simpleTypeText DifferenceTypeEnum_Value = "Value"
    simpleTypeText DifferenceTypeEnum_Reference = "Reference"
    simpleTypeText DifferenceTypeEnum_Structure = "Structure"
    simpleTypeText DifferenceTypeEnum_Scheme = "Scheme"
 
-- | The method of calculating discounted payment amounts
data DiscountingTypeEnum
    = DiscountingTypeEnum_Standard
      -- ^ Per ISDA 2000 Definitions, Section 8.4. Discounting, 
      --   paragraph (a)
    | DiscountingTypeEnum_FRA
      -- ^ Per ISDA 2000 Definitions, Section 8.4. Discounting, 
      --   paragraph (b)
    deriving (Eq,Show,Enum)
instance SchemaType DiscountingTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DiscountingTypeEnum where
    acceptingParser =  do isWord "Standard"; return DiscountingTypeEnum_Standard
                      `onFail` do isWord "FRA"; return DiscountingTypeEnum_FRA
                      
    simpleTypeText DiscountingTypeEnum_Standard = "Standard"
    simpleTypeText DiscountingTypeEnum_FRA = "FRA"
 
-- | The specification of how disruption fallbacks will be 
--   represented.
data DisruptionFallbacksEnum
    = DisruptionFallbacksEnum_AsSpecifiedInMasterAgreement
      -- ^ The Disruption Fallback(s) are determined by reference to 
      --   the relevant Master Agreement.
    | DisruptionFallbacksEnum_AsSpecifiedInConfirmation
      -- ^ The Disruption Fallback(s) are determined by reference to 
      --   the relevant Confirmation.
    deriving (Eq,Show,Enum)
instance SchemaType DisruptionFallbacksEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DisruptionFallbacksEnum where
    acceptingParser =  do isWord "AsSpecifiedInMasterAgreement"; return DisruptionFallbacksEnum_AsSpecifiedInMasterAgreement
                      `onFail` do isWord "AsSpecifiedInConfirmation"; return DisruptionFallbacksEnum_AsSpecifiedInConfirmation
                      
    simpleTypeText DisruptionFallbacksEnum_AsSpecifiedInMasterAgreement = "AsSpecifiedInMasterAgreement"
    simpleTypeText DisruptionFallbacksEnum_AsSpecifiedInConfirmation = "AsSpecifiedInConfirmation"
 
-- | Refers to one on the 3 Amounts
data DividendAmountTypeEnum
    = DividendAmountTypeEnum_RecordAmount
      -- ^ 100% of the gross cash dividend per Share paid over record 
      --   date during relevant Dividend Period
    | DividendAmountTypeEnum_ExAmount
      -- ^ 100% of gross cash dividend per Share paid after the Ex Div 
      --   date during relevant Dividend Period.
    | DividendAmountTypeEnum_PaidAmount
      -- ^ 100% of gross cash dividend per Share paid during relevant 
      --   Dividend Period.
    | DividendAmountTypeEnum_AsSpecifiedInMasterConfirmation
      -- ^ The Amount is determined as provided in the relevant Master 
      --   Confirmation.
    deriving (Eq,Show,Enum)
instance SchemaType DividendAmountTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DividendAmountTypeEnum where
    acceptingParser =  do isWord "RecordAmount"; return DividendAmountTypeEnum_RecordAmount
                      `onFail` do isWord "ExAmount"; return DividendAmountTypeEnum_ExAmount
                      `onFail` do isWord "PaidAmount"; return DividendAmountTypeEnum_PaidAmount
                      `onFail` do isWord "AsSpecifiedInMasterConfirmation"; return DividendAmountTypeEnum_AsSpecifiedInMasterConfirmation
                      
    simpleTypeText DividendAmountTypeEnum_RecordAmount = "RecordAmount"
    simpleTypeText DividendAmountTypeEnum_ExAmount = "ExAmount"
    simpleTypeText DividendAmountTypeEnum_PaidAmount = "PaidAmount"
    simpleTypeText DividendAmountTypeEnum_AsSpecifiedInMasterConfirmation = "AsSpecifiedInMasterConfirmation"
 
-- | Defines how the composition of dividends is to be 
--   determined.
data DividendCompositionEnum
    = DividendCompositionEnum_EquityAmountReceiverElection
      -- ^ The Equity Amount Receiver determines the composition of 
      --   dividends (subject to conditions).
    | DividendCompositionEnum_CalculationAgentElection
      -- ^ The Calculation Agent determines the composition of 
      --   dividends (subject to conditions).
    deriving (Eq,Show,Enum)
instance SchemaType DividendCompositionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DividendCompositionEnum where
    acceptingParser =  do isWord "EquityAmountReceiverElection"; return DividendCompositionEnum_EquityAmountReceiverElection
                      `onFail` do isWord "CalculationAgentElection"; return DividendCompositionEnum_CalculationAgentElection
                      
    simpleTypeText DividendCompositionEnum_EquityAmountReceiverElection = "EquityAmountReceiverElection"
    simpleTypeText DividendCompositionEnum_CalculationAgentElection = "CalculationAgentElection"
 
-- | The reference to a dividend date.
data DividendDateReferenceEnum
    = DividendDateReferenceEnum_ExDate
      -- ^ Date on which a holder of the security is entitled to the 
      --   dividend.
    | DividendDateReferenceEnum_DividendPaymentDate
      -- ^ Date on which the dividend will be paid by the issuer.
    | DividendDateReferenceEnum_DividendValuationDate
      -- ^ In respect of each Dividend Period, number of days offset 
      --   from the relevant Dividend Valuation Date.
    | DividendDateReferenceEnum_RecordDate
      -- ^ Date on which the dividend will be recorded in the books of 
      --   the paying agent.
    | DividendDateReferenceEnum_TerminationDate
      -- ^ Termination date of the swap.
    | DividendDateReferenceEnum_EquityPaymentDate
      -- ^ Equity payment date of the swap.
    | DividendDateReferenceEnum_FollowingPaymentDate
      -- ^ The next payment date of the swap.
    | DividendDateReferenceEnum_AdHocDate
      -- ^ The dividend date will be specified ad hoc by the parties, 
      --   typically on the dividend ex-date
    | DividendDateReferenceEnum_CumulativeEquityPaid
      -- ^ Total of paid dividends, paid on next following Cash 
      --   Settlement Payment Date, which is immediately following the 
      --   Dividend Period during which the dividend is paid by the 
      --   Issuer to the holders of record of a Share.
    | DividendDateReferenceEnum_CumulativeLiborPaid
      -- ^ Total of paid dividends, paid on next following Payment 
      --   Date, which is immediately following the Dividend Period 
      --   during which the dividend is paid by the Issuer to the 
      --   holders of record of a Share.
    | DividendDateReferenceEnum_CumulativeEquityExDiv
      -- ^ Total of dividends which go ex, paid on next following Cash 
      --   Settlement Payment Date, which is immediately following the 
      --   Dividend Period during which the Shares commence trading 
      --   ex-dividend on the Exchange
    | DividendDateReferenceEnum_CumulativeLiborExDiv
      -- ^ Total of dividends which go ex, paid on next following 
      --   Payment Date, which is immediately following the Dividend 
      --   Period during which the Shares commence trading ex-dividend 
      --   on the Exchange, or where the date on which the Shares 
      --   commence trading ex-dividend is a Payment Date, such 
      --   Payment Date.
    | DividendDateReferenceEnum_SharePayment
      -- ^ If "Dividend Payment Date(s)" is specified in the 
      --   Transaction Supplement as "Share Payment", then the 
      --   Dividend Payment Date in respect of a Dividend Amount shall 
      --   fall on a date on or before the date that is two (or any 
      --   other number that is specified in the Transaction 
      --   Supplement) Currency Business Days following the day on 
      --   which the Issuer of the Shares pays the relevant dividend 
      --   to holders of record of the Shares
    | DividendDateReferenceEnum_CashSettlementPaymentDate
      -- ^ If "Dividend Payment Date(s)" is specified in the 
      --   Transaction Supplement as "Cash Settlement Payment Date", 
      --   then the Dividend Payment Date in respect of a Dividend 
      --   Amount shall be the Cash Settlement Payment Date relating 
      --   to the end of the Dividend Period during which the Shares 
      --   commenced trading "ex" the relevant dividend on the 
      --   Exchange
    | DividendDateReferenceEnum_FloatingAmountPaymentDate
      -- ^ If "Dividend Payment Date(s)" is specified in the 
      --   Transaction Supplement as "Floating Amount Payment Date", 
      --   then the Dividend Payment Date in respect of a Dividend 
      --   Amount shall be the first Payment Date falling at least one 
      --   Settlement Cycle after the date that the Shares have 
      --   commenced trading "ex" the relevant dividend on the 
      --   Exchange.
    | DividendDateReferenceEnum_CashSettlePaymentDateExDiv
      -- ^ If "Dividend Payment Date(s)" is specified in the 
      --   Transaction Supplement as "Cash Settlement Payment Date – 
      --   Ex Dividend", then the Dividend Payment Date in respect of 
      --   a Dividend Amount shall be the Cash Settlement Payment Date 
      --   relating to the end of the Dividend Period during which the 
      --   Shares commenced trading “ex” the relevant dividend on 
      --   the Exchange.
    | DividendDateReferenceEnum_CashSettlePaymentDateIssuerPayment
      -- ^ If "Dividend Payment Date(s)" is specified in the 
      --   Transaction Supplement as "Cash Settlement Payment Date – 
      --   Issuer Payment", then the Dividend Payment Date in respect 
      --   of a Dividend Amount shall be the Cash Settlement Payment 
      --   Date relating to the end of the Dividend Period during 
      --   which the issuer pays the relevant dividend to a holder of 
      --   record provided that in the case where the Equity Amount 
      --   Payer is the party specified to be the sole Hedging Party 
      --   and the Hedging Party has not received the Dividend Amount 
      --   by such date, then the date falling a number of Currency 
      --   Business Days as specified in the Cash Settlement Payment 
      --   Date after actual receipt by the Hedging Party of the 
      --   Received Ex Amount or Paid Ex Amount (as applicable).
    | DividendDateReferenceEnum_ExDividendPaymentDate
      -- ^ If "Dividend Payment Date(s)" is specified in the 
      --   Transaction Supplement as "Ex-dividend Payment Date", then 
      --   the Dividend Payment Date in respect of a Dividend Amount 
      --   shall be the number of Currency Business Days as provided 
      --   in the Transaction Supplement following the day on which 
      --   the Shares commence trading ‘ex’ on the Exchange.
    deriving (Eq,Show,Enum)
instance SchemaType DividendDateReferenceEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DividendDateReferenceEnum where
    acceptingParser =  do isWord "ExDate"; return DividendDateReferenceEnum_ExDate
                      `onFail` do isWord "DividendPaymentDate"; return DividendDateReferenceEnum_DividendPaymentDate
                      `onFail` do isWord "DividendValuationDate"; return DividendDateReferenceEnum_DividendValuationDate
                      `onFail` do isWord "RecordDate"; return DividendDateReferenceEnum_RecordDate
                      `onFail` do isWord "TerminationDate"; return DividendDateReferenceEnum_TerminationDate
                      `onFail` do isWord "EquityPaymentDate"; return DividendDateReferenceEnum_EquityPaymentDate
                      `onFail` do isWord "FollowingPaymentDate"; return DividendDateReferenceEnum_FollowingPaymentDate
                      `onFail` do isWord "AdHocDate"; return DividendDateReferenceEnum_AdHocDate
                      `onFail` do isWord "CumulativeEquityPaid"; return DividendDateReferenceEnum_CumulativeEquityPaid
                      `onFail` do isWord "CumulativeLiborPaid"; return DividendDateReferenceEnum_CumulativeLiborPaid
                      `onFail` do isWord "CumulativeEquityExDiv"; return DividendDateReferenceEnum_CumulativeEquityExDiv
                      `onFail` do isWord "CumulativeLiborExDiv"; return DividendDateReferenceEnum_CumulativeLiborExDiv
                      `onFail` do isWord "SharePayment"; return DividendDateReferenceEnum_SharePayment
                      `onFail` do isWord "CashSettlementPaymentDate"; return DividendDateReferenceEnum_CashSettlementPaymentDate
                      `onFail` do isWord "FloatingAmountPaymentDate"; return DividendDateReferenceEnum_FloatingAmountPaymentDate
                      `onFail` do isWord "CashSettlePaymentDateExDiv"; return DividendDateReferenceEnum_CashSettlePaymentDateExDiv
                      `onFail` do isWord "CashSettlePaymentDateIssuerPayment"; return DividendDateReferenceEnum_CashSettlePaymentDateIssuerPayment
                      `onFail` do isWord "ExDividendPaymentDate"; return DividendDateReferenceEnum_ExDividendPaymentDate
                      
    simpleTypeText DividendDateReferenceEnum_ExDate = "ExDate"
    simpleTypeText DividendDateReferenceEnum_DividendPaymentDate = "DividendPaymentDate"
    simpleTypeText DividendDateReferenceEnum_DividendValuationDate = "DividendValuationDate"
    simpleTypeText DividendDateReferenceEnum_RecordDate = "RecordDate"
    simpleTypeText DividendDateReferenceEnum_TerminationDate = "TerminationDate"
    simpleTypeText DividendDateReferenceEnum_EquityPaymentDate = "EquityPaymentDate"
    simpleTypeText DividendDateReferenceEnum_FollowingPaymentDate = "FollowingPaymentDate"
    simpleTypeText DividendDateReferenceEnum_AdHocDate = "AdHocDate"
    simpleTypeText DividendDateReferenceEnum_CumulativeEquityPaid = "CumulativeEquityPaid"
    simpleTypeText DividendDateReferenceEnum_CumulativeLiborPaid = "CumulativeLiborPaid"
    simpleTypeText DividendDateReferenceEnum_CumulativeEquityExDiv = "CumulativeEquityExDiv"
    simpleTypeText DividendDateReferenceEnum_CumulativeLiborExDiv = "CumulativeLiborExDiv"
    simpleTypeText DividendDateReferenceEnum_SharePayment = "SharePayment"
    simpleTypeText DividendDateReferenceEnum_CashSettlementPaymentDate = "CashSettlementPaymentDate"
    simpleTypeText DividendDateReferenceEnum_FloatingAmountPaymentDate = "FloatingAmountPaymentDate"
    simpleTypeText DividendDateReferenceEnum_CashSettlePaymentDateExDiv = "CashSettlePaymentDateExDiv"
    simpleTypeText DividendDateReferenceEnum_CashSettlePaymentDateIssuerPayment = "CashSettlePaymentDateIssuerPayment"
    simpleTypeText DividendDateReferenceEnum_ExDividendPaymentDate = "ExDividendPaymentDate"
 
-- | The date on which the receiver of the equity return is 
--   entitled to the dividend.
data DividendEntitlementEnum
    = DividendEntitlementEnum_ExDate
      -- ^ Dividend entitlement is on the dividend ex-date.
    | DividendEntitlementEnum_RecordDate
      -- ^ Dividend entitlement is on the dividend record date.
    deriving (Eq,Show,Enum)
instance SchemaType DividendEntitlementEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DividendEntitlementEnum where
    acceptingParser =  do isWord "ExDate"; return DividendEntitlementEnum_ExDate
                      `onFail` do isWord "RecordDate"; return DividendEntitlementEnum_RecordDate
                      
    simpleTypeText DividendEntitlementEnum_ExDate = "ExDate"
    simpleTypeText DividendEntitlementEnum_RecordDate = "RecordDate"
 
-- | Defines the First Period or the Second Period, as specified 
--   in the 2002 ISDA Equity Derivatives Definitions.
data DividendPeriodEnum
    = DividendPeriodEnum_FirstPeriod
      -- ^ "First Period" per the 2002 ISDA Equity Derivatives 
      --   Definitions will apply.
    | DividendPeriodEnum_SecondPeriod
      -- ^ "Second Period" per the 2002 ISDA Equity Derivatives 
      --   Definitions will apply.
    deriving (Eq,Show,Enum)
instance SchemaType DividendPeriodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DividendPeriodEnum where
    acceptingParser =  do isWord "FirstPeriod"; return DividendPeriodEnum_FirstPeriod
                      `onFail` do isWord "SecondPeriod"; return DividendPeriodEnum_SecondPeriod
                      
    simpleTypeText DividendPeriodEnum_FirstPeriod = "FirstPeriod"
    simpleTypeText DividendPeriodEnum_SecondPeriod = "SecondPeriod"
 
-- | A type which permits the Dual Currency strike quote basis 
--   to be expressed in terms of the deposit and alternate 
--   currencies.
data DualCurrencyStrikeQuoteBasisEnum
    = DualCurrencyStrikeQuoteBasisEnum_DepositCurrencyPerAlternateCurrency
    | DualCurrencyStrikeQuoteBasisEnum_AlternateCurrencyPerDepositCurrency
    deriving (Eq,Show,Enum)
instance SchemaType DualCurrencyStrikeQuoteBasisEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType DualCurrencyStrikeQuoteBasisEnum where
    acceptingParser =  do isWord "DepositCurrencyPerAlternateCurrency"; return DualCurrencyStrikeQuoteBasisEnum_DepositCurrencyPerAlternateCurrency
                      `onFail` do isWord "AlternateCurrencyPerDepositCurrency"; return DualCurrencyStrikeQuoteBasisEnum_AlternateCurrencyPerDepositCurrency
                      
    simpleTypeText DualCurrencyStrikeQuoteBasisEnum_DepositCurrencyPerAlternateCurrency = "DepositCurrencyPerAlternateCurrency"
    simpleTypeText DualCurrencyStrikeQuoteBasisEnum_AlternateCurrencyPerDepositCurrency = "AlternateCurrencyPerDepositCurrency"
 
-- | The type of electricity product.
data ElectricityProductTypeEnum
    = ElectricityProductTypeEnum_Electricity
    deriving (Eq,Show,Enum)
instance SchemaType ElectricityProductTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType ElectricityProductTypeEnum where
    acceptingParser =  do isWord "Electricity"; return ElectricityProductTypeEnum_Electricity
                      
    simpleTypeText ElectricityProductTypeEnum_Electricity = "Electricity"
 
-- | Specifies an additional Forward type.
data EquityOptionTypeEnum
    = EquityOptionTypeEnum_Put
      -- ^ A put option gives the holder the right to sell the 
      --   underlying asset by a certain date for a certain price.
    | EquityOptionTypeEnum_Call
      -- ^ A call option gives the holder the right to buy the 
      --   underlying asset by a certain date for a certain price.
    | EquityOptionTypeEnum_Forward
      -- ^ DEPRECATED value which will be removed in FpML-5-0 onwards 
      --   A forward contract is an agreement to buy or sell the 
      --   underlying asset at a certain future time for a certain 
      --   price.
    deriving (Eq,Show,Enum)
instance SchemaType EquityOptionTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType EquityOptionTypeEnum where
    acceptingParser =  do isWord "Put"; return EquityOptionTypeEnum_Put
                      `onFail` do isWord "Call"; return EquityOptionTypeEnum_Call
                      `onFail` do isWord "Forward"; return EquityOptionTypeEnum_Forward
                      
    simpleTypeText EquityOptionTypeEnum_Put = "Put"
    simpleTypeText EquityOptionTypeEnum_Call = "Call"
    simpleTypeText EquityOptionTypeEnum_Forward = "Forward"
 
-- | The specification of how an OTC option will be exercised.
data ExerciseStyleEnum
    = ExerciseStyleEnum_American
      -- ^ Option can be exercised on any date up to the expiry date.
    | ExerciseStyleEnum_Bermuda
      -- ^ Option can be exercised on specified dates up to the expiry 
      --   date.
    | ExerciseStyleEnum_European
      -- ^ Option can only be exercised on the expiry date.
    deriving (Eq,Show,Enum)
instance SchemaType ExerciseStyleEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType ExerciseStyleEnum where
    acceptingParser =  do isWord "American"; return ExerciseStyleEnum_American
                      `onFail` do isWord "Bermuda"; return ExerciseStyleEnum_Bermuda
                      `onFail` do isWord "European"; return ExerciseStyleEnum_European
                      
    simpleTypeText ExerciseStyleEnum_American = "American"
    simpleTypeText ExerciseStyleEnum_Bermuda = "Bermuda"
    simpleTypeText ExerciseStyleEnum_European = "European"
 
-- | Defines the fee type.
data FeeElectionEnum
    = FeeElectionEnum_FlatFee
      -- ^ The product of (i) the Break Fee Rate multiplied by (ii) 
      --   the Equity Notional Amount corresponding to the Early 
      --   Termination Portion.
    | FeeElectionEnum_AmortizedFee
      -- ^ The product of (i) the Break Fee Rate multiplied by (ii) 
      --   the Equity Notional Amount corresponding to the Early 
      --   Termination Portion multiplied by (iii) the number of days 
      --   from the Early Termination Date to the later of the 
      --   Termination Date or the Cash Settlement Payment Date 
      --   corresponding to the latest Valuation Date.
    | FeeElectionEnum_FundingFee
      -- ^ The product of (i) the Equity Notional Amount corresponding 
      --   to the Early Termination Portion multiplied by (ii) the 
      --   Break Funding Rate multiplied by (iii) the number of days 
      --   from the Early Termination Date to the next scheduled Reset 
      --   Date divided by (iv) a number equivalent to the denominator 
      --   of the Day Count Fraction applicable to the Floating Rate 
      --   Option.
    | FeeElectionEnum_FlatFeeAndFundingFee
      -- ^ Both Flat Fee and Funding Fee are applicable.
    | FeeElectionEnum_AmortizedFeeAndFundingFee
      -- ^ Amortized Fee and Funding Fee are applicable.
    deriving (Eq,Show,Enum)
instance SchemaType FeeElectionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType FeeElectionEnum where
    acceptingParser =  do isWord "FlatFee"; return FeeElectionEnum_FlatFee
                      `onFail` do isWord "AmortizedFee"; return FeeElectionEnum_AmortizedFee
                      `onFail` do isWord "FundingFee"; return FeeElectionEnum_FundingFee
                      `onFail` do isWord "FlatFeeAndFundingFee"; return FeeElectionEnum_FlatFeeAndFundingFee
                      `onFail` do isWord "AmortizedFeeAndFundingFee"; return FeeElectionEnum_AmortizedFeeAndFundingFee
                      
    simpleTypeText FeeElectionEnum_FlatFee = "FlatFee"
    simpleTypeText FeeElectionEnum_AmortizedFee = "AmortizedFee"
    simpleTypeText FeeElectionEnum_FundingFee = "FundingFee"
    simpleTypeText FeeElectionEnum_FlatFeeAndFundingFee = "FlatFeeAndFundingFee"
    simpleTypeText FeeElectionEnum_AmortizedFeeAndFundingFee = "AmortizedFeeAndFundingFee"
 
-- | The method by which the Flat Rate is calculated for a 
--   commodity freight transaction.
data FlatRateEnum
    = FlatRateEnum_Fixed
      -- ^ The Flat Rate will be the New Worldwide Tanker Nominal 
      --   Freight Scale for the Freight Index Route for the Trade 
      --   Date for the transaction.
    | FlatRateEnum_Floating
      -- ^ The Flat Rate for each Pricing Date will be the New 
      --   Worldwide Tanker Nominal Freight Scale for the Freight 
      --   Index Route for the Pricing Date..
    deriving (Eq,Show,Enum)
instance SchemaType FlatRateEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType FlatRateEnum where
    acceptingParser =  do isWord "Fixed"; return FlatRateEnum_Fixed
                      `onFail` do isWord "Floating"; return FlatRateEnum_Floating
                      
    simpleTypeText FlatRateEnum_Fixed = "Fixed"
    simpleTypeText FlatRateEnum_Floating = "Floating"
 
-- | Specifies the fallback provisions in respect to the 
--   applicable Futures Price Valuation.
data FPVFinalPriceElectionFallbackEnum
    = FPVFinalPriceElectionFallbackEnum_FPVClose
      -- ^ In respect of the Early Final Valuation Date, the 
      --   provisions for FPV Close shall apply.
    | FPVFinalPriceElectionFallbackEnum_FPVHedgeExecution
      -- ^ In respect of the Early Final Valuation Date, the 
      --   provisions for FPV Hedge Execution shall apply.
    deriving (Eq,Show,Enum)
instance SchemaType FPVFinalPriceElectionFallbackEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType FPVFinalPriceElectionFallbackEnum where
    acceptingParser =  do isWord "FPVClose"; return FPVFinalPriceElectionFallbackEnum_FPVClose
                      `onFail` do isWord "FPVHedgeExecution"; return FPVFinalPriceElectionFallbackEnum_FPVHedgeExecution
                      
    simpleTypeText FPVFinalPriceElectionFallbackEnum_FPVClose = "FPVClose"
    simpleTypeText FPVFinalPriceElectionFallbackEnum_FPVHedgeExecution = "FPVHedgeExecution"
 
-- | The method of FRA discounting, if any, that will apply.
data FraDiscountingEnum
    = FraDiscountingEnum_ISDA
      -- ^ "FRA Discounting" per the ISDA Definitions will apply.
    | FraDiscountingEnum_AFMA
      -- ^ FRA discounting per the Australian Financial Markets 
      --   Association (AFMA) OTC Financial Product Conventions will 
      --   apply.
    | FraDiscountingEnum_NONE
      -- ^ No discounting will apply.
    deriving (Eq,Show,Enum)
instance SchemaType FraDiscountingEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType FraDiscountingEnum where
    acceptingParser =  do isWord "ISDA"; return FraDiscountingEnum_ISDA
                      `onFail` do isWord "AFMA"; return FraDiscountingEnum_AFMA
                      `onFail` do isWord "NONE"; return FraDiscountingEnum_NONE
                      
    simpleTypeText FraDiscountingEnum_ISDA = "ISDA"
    simpleTypeText FraDiscountingEnum_AFMA = "AFMA"
    simpleTypeText FraDiscountingEnum_NONE = "NONE"
 
-- | The schedule frequency type
data FrequencyTypeEnum
    = FrequencyTypeEnum_Day
      -- ^ Day is the unit of frequency.
    | FrequencyTypeEnum_Business
      -- ^ TBD
    deriving (Eq,Show,Enum)
instance SchemaType FrequencyTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType FrequencyTypeEnum where
    acceptingParser =  do isWord "Day"; return FrequencyTypeEnum_Day
                      `onFail` do isWord "Business"; return FrequencyTypeEnum_Business
                      
    simpleTypeText FrequencyTypeEnum_Day = "Day"
    simpleTypeText FrequencyTypeEnum_Business = "Business"
 
-- | The specification of whether a barrier within an FX OTC 
--   option is a knockin or knockout, as well as whether it is a 
--   standard barrier or a reverse barrier.
data FxBarrierTypeEnum
    = FxBarrierTypeEnum_Knockin
      -- ^ Option exists once the barrier is hit. The trigger rate is 
      --   out-of-the money in relation to the strike rate.
    | FxBarrierTypeEnum_Knockout
      -- ^ Option ceases to exist once the barrier is hit. The trigger 
      --   rate is out-of the-money in relation to the strike rate.
    | FxBarrierTypeEnum_ReverseKnockin
      -- ^ Option exists once the barrier is hit. The trigger rate is 
      --   in-the money in relation to the strike rate.
    | FxBarrierTypeEnum_ReverseKnockout
      -- ^ Option ceases to exist once the barrier is hit. The trigger 
      --   rate is in-the money in relation to the strike rate.
    deriving (Eq,Show,Enum)
instance SchemaType FxBarrierTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType FxBarrierTypeEnum where
    acceptingParser =  do isWord "Knockin"; return FxBarrierTypeEnum_Knockin
                      `onFail` do isWord "Knockout"; return FxBarrierTypeEnum_Knockout
                      `onFail` do isWord "ReverseKnockin"; return FxBarrierTypeEnum_ReverseKnockin
                      `onFail` do isWord "ReverseKnockout"; return FxBarrierTypeEnum_ReverseKnockout
                      
    simpleTypeText FxBarrierTypeEnum_Knockin = "Knockin"
    simpleTypeText FxBarrierTypeEnum_Knockout = "Knockout"
    simpleTypeText FxBarrierTypeEnum_ReverseKnockin = "ReverseKnockin"
    simpleTypeText FxBarrierTypeEnum_ReverseKnockout = "ReverseKnockout"
 
-- | The specification of a time period containing values such 
--   as Today, Tomorrow etc.
data FxTenorPeriodEnum
    = FxTenorPeriodEnum_Broken
      -- ^ Broken/non conventional Tenor Period.
    | FxTenorPeriodEnum_Today
      -- ^ Today Tenor Period.
    | FxTenorPeriodEnum_Tomorrow
      -- ^ Tomorrow Tenor Period.
    | FxTenorPeriodEnum_TomorrowNext
      -- ^ Day after Tomorrow Tenor Period.
    | FxTenorPeriodEnum_Spot
      -- ^ Spot Tenor Period.
    | FxTenorPeriodEnum_SpotNext
      -- ^ Day after Spot Tenor period.
    deriving (Eq,Show,Enum)
instance SchemaType FxTenorPeriodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType FxTenorPeriodEnum where
    acceptingParser =  do isWord "Broken"; return FxTenorPeriodEnum_Broken
                      `onFail` do isWord "Today"; return FxTenorPeriodEnum_Today
                      `onFail` do isWord "Tomorrow"; return FxTenorPeriodEnum_Tomorrow
                      `onFail` do isWord "TomorrowNext"; return FxTenorPeriodEnum_TomorrowNext
                      `onFail` do isWord "Spot"; return FxTenorPeriodEnum_Spot
                      `onFail` do isWord "SpotNext"; return FxTenorPeriodEnum_SpotNext
                      
    simpleTypeText FxTenorPeriodEnum_Broken = "Broken"
    simpleTypeText FxTenorPeriodEnum_Today = "Today"
    simpleTypeText FxTenorPeriodEnum_Tomorrow = "Tomorrow"
    simpleTypeText FxTenorPeriodEnum_TomorrowNext = "TomorrowNext"
    simpleTypeText FxTenorPeriodEnum_Spot = "Spot"
    simpleTypeText FxTenorPeriodEnum_SpotNext = "SpotNext"
 
-- | The type of gas product.
data GasProductTypeEnum
    = GasProductTypeEnum_NaturalGas
    deriving (Eq,Show,Enum)
instance SchemaType GasProductTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType GasProductTypeEnum where
    acceptingParser =  do isWord "NaturalGas"; return GasProductTypeEnum_NaturalGas
                      
    simpleTypeText GasProductTypeEnum_NaturalGas = "NaturalGas"
 
-- | The type of independent amount convention.
data IndependentAmountConventionEnum
    = IndependentAmountConventionEnum_NettedAfterThreshold
    | IndependentAmountConventionEnum_NettedBeforeThreshold
    | IndependentAmountConventionEnum_Segregated
    deriving (Eq,Show,Enum)
instance SchemaType IndependentAmountConventionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType IndependentAmountConventionEnum where
    acceptingParser =  do isWord "NettedAfterThreshold"; return IndependentAmountConventionEnum_NettedAfterThreshold
                      `onFail` do isWord "NettedBeforeThreshold"; return IndependentAmountConventionEnum_NettedBeforeThreshold
                      `onFail` do isWord "Segregated"; return IndependentAmountConventionEnum_Segregated
                      
    simpleTypeText IndependentAmountConventionEnum_NettedAfterThreshold = "NettedAfterThreshold"
    simpleTypeText IndependentAmountConventionEnum_NettedBeforeThreshold = "NettedBeforeThreshold"
    simpleTypeText IndependentAmountConventionEnum_Segregated = "Segregated"
 
-- | The specification of the consequences of Index Events.
data IndexEventConsequenceEnum
    = IndexEventConsequenceEnum_CalculationAgentAdjustment
      -- ^ Calculation Agent Adjustment
    | IndexEventConsequenceEnum_NegotiatedCloseOut
      -- ^ Negotiated Close Out
    | IndexEventConsequenceEnum_CancellationAndPayment
      -- ^ Cancellation and Payment
    | IndexEventConsequenceEnum_RelatedExchange
      -- ^ Related Exchange Adjustment
    deriving (Eq,Show,Enum)
instance SchemaType IndexEventConsequenceEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType IndexEventConsequenceEnum where
    acceptingParser =  do isWord "CalculationAgentAdjustment"; return IndexEventConsequenceEnum_CalculationAgentAdjustment
                      `onFail` do isWord "NegotiatedCloseOut"; return IndexEventConsequenceEnum_NegotiatedCloseOut
                      `onFail` do isWord "CancellationAndPayment"; return IndexEventConsequenceEnum_CancellationAndPayment
                      `onFail` do isWord "RelatedExchange"; return IndexEventConsequenceEnum_RelatedExchange
                      
    simpleTypeText IndexEventConsequenceEnum_CalculationAgentAdjustment = "CalculationAgentAdjustment"
    simpleTypeText IndexEventConsequenceEnum_NegotiatedCloseOut = "NegotiatedCloseOut"
    simpleTypeText IndexEventConsequenceEnum_CancellationAndPayment = "CancellationAndPayment"
    simpleTypeText IndexEventConsequenceEnum_RelatedExchange = "RelatedExchange"
 
-- | &gt;Defines whether agent bank is making an interest 
--   payment based on the lender pro-rata share at the end of 
--   the period or based on the lender position throughout the 
--   period. Agent Banks decide which way to calculate the 
--   interest for a deal.
data InterestCalculationMethodEnum
    = InterestCalculationMethodEnum_ProRataShare
      -- ^ Agent bank is making an interest payment based on the 
      --   lender pro-rata share.
    | InterestCalculationMethodEnum_FacilityPosition
      -- ^ Agent bank is making an interest payment based on the 
      --   lender position throughout the period.
    deriving (Eq,Show,Enum)
instance SchemaType InterestCalculationMethodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType InterestCalculationMethodEnum where
    acceptingParser =  do isWord "ProRataShare"; return InterestCalculationMethodEnum_ProRataShare
                      `onFail` do isWord "FacilityPosition"; return InterestCalculationMethodEnum_FacilityPosition
                      
    simpleTypeText InterestCalculationMethodEnum_ProRataShare = "ProRataShare"
    simpleTypeText InterestCalculationMethodEnum_FacilityPosition = "FacilityPosition"
 
-- | The type of calculation.
data InterestCalculationTypeEnum
    = InterestCalculationTypeEnum_Simple
    | InterestCalculationTypeEnum_Compounding
    deriving (Eq,Show,Enum)
instance SchemaType InterestCalculationTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType InterestCalculationTypeEnum where
    acceptingParser =  do isWord "Simple"; return InterestCalculationTypeEnum_Simple
                      `onFail` do isWord "Compounding"; return InterestCalculationTypeEnum_Compounding
                      
    simpleTypeText InterestCalculationTypeEnum_Simple = "Simple"
    simpleTypeText InterestCalculationTypeEnum_Compounding = "Compounding"
 
-- | The type of method.
data InterestMethodEnum
    = InterestMethodEnum_PhysicalSettlement
    | InterestMethodEnum_RollIn
    deriving (Eq,Show,Enum)
instance SchemaType InterestMethodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType InterestMethodEnum where
    acceptingParser =  do isWord "PhysicalSettlement"; return InterestMethodEnum_PhysicalSettlement
                      `onFail` do isWord "RollIn"; return InterestMethodEnum_RollIn
                      
    simpleTypeText InterestMethodEnum_PhysicalSettlement = "PhysicalSettlement"
    simpleTypeText InterestMethodEnum_RollIn = "RollIn"
 
-- | The specification of the interest shortfall cap, applicable 
--   to mortgage derivatives.
data InterestShortfallCapEnum
    = InterestShortfallCapEnum_Fixed
    | InterestShortfallCapEnum_Variable
    deriving (Eq,Show,Enum)
instance SchemaType InterestShortfallCapEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType InterestShortfallCapEnum where
    acceptingParser =  do isWord "Fixed"; return InterestShortfallCapEnum_Fixed
                      `onFail` do isWord "Variable"; return InterestShortfallCapEnum_Variable
                      
    simpleTypeText InterestShortfallCapEnum_Fixed = "Fixed"
    simpleTypeText InterestShortfallCapEnum_Variable = "Variable"
 
-- | Defines applicable periods for interpolation.
data InterpolationPeriodEnum
    = InterpolationPeriodEnum_Initial
      -- ^ Interpolation is applicable to the initial period only.
    | InterpolationPeriodEnum_InitialAndFinal
      -- ^ Interpolation is applicable to the initial and final 
      --   periods only.
    | InterpolationPeriodEnum_Final
      -- ^ Interpolation is applicable to the final period only.
    | InterpolationPeriodEnum_AnyPeriod
      -- ^ Interpolation is applicable to any non-standard period.
    deriving (Eq,Show,Enum)
instance SchemaType InterpolationPeriodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType InterpolationPeriodEnum where
    acceptingParser =  do isWord "Initial"; return InterpolationPeriodEnum_Initial
                      `onFail` do isWord "InitialAndFinal"; return InterpolationPeriodEnum_InitialAndFinal
                      `onFail` do isWord "Final"; return InterpolationPeriodEnum_Final
                      `onFail` do isWord "AnyPeriod"; return InterpolationPeriodEnum_AnyPeriod
                      
    simpleTypeText InterpolationPeriodEnum_Initial = "Initial"
    simpleTypeText InterpolationPeriodEnum_InitialAndFinal = "InitialAndFinal"
    simpleTypeText InterpolationPeriodEnum_Final = "Final"
    simpleTypeText InterpolationPeriodEnum_AnyPeriod = "AnyPeriod"
 
-- | Used for indicating the length unit in the Resource type.
data LengthUnitEnum
    = LengthUnitEnum_Pages
    | LengthUnitEnum_TimeUnit
    deriving (Eq,Show,Enum)
instance SchemaType LengthUnitEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType LengthUnitEnum where
    acceptingParser =  do isWord "Pages"; return LengthUnitEnum_Pages
                      `onFail` do isWord "TimeUnit"; return LengthUnitEnum_TimeUnit
                      
    simpleTypeText LengthUnitEnum_Pages = "Pages"
    simpleTypeText LengthUnitEnum_TimeUnit = "TimeUnit"
 
-- | The specification of how market disruption events will be 
--   represented.
data MarketDisruptionEventsEnum
    = MarketDisruptionEventsEnum_Applicable
      -- ^ Market Disruption Events are applicable.
    | MarketDisruptionEventsEnum_NotApplicable
      -- ^ Market Disruption Events are not applicable.
    | MarketDisruptionEventsEnum_AsSpecifiedInMasterAgreement
      -- ^ The Market Disruption Event(s) are determined by reference 
      --   to the relevant Master Agreement.
    | MarketDisruptionEventsEnum_AsSpecifiedInConfirmation
      -- ^ The Market Disruption Event(s) are determined by reference 
      --   to the relevant Confirmation.
    deriving (Eq,Show,Enum)
instance SchemaType MarketDisruptionEventsEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType MarketDisruptionEventsEnum where
    acceptingParser =  do isWord "Applicable"; return MarketDisruptionEventsEnum_Applicable
                      `onFail` do isWord "NotApplicable"; return MarketDisruptionEventsEnum_NotApplicable
                      `onFail` do isWord "AsSpecifiedInMasterAgreement"; return MarketDisruptionEventsEnum_AsSpecifiedInMasterAgreement
                      `onFail` do isWord "AsSpecifiedInConfirmation"; return MarketDisruptionEventsEnum_AsSpecifiedInConfirmation
                      
    simpleTypeText MarketDisruptionEventsEnum_Applicable = "Applicable"
    simpleTypeText MarketDisruptionEventsEnum_NotApplicable = "NotApplicable"
    simpleTypeText MarketDisruptionEventsEnum_AsSpecifiedInMasterAgreement = "AsSpecifiedInMasterAgreement"
    simpleTypeText MarketDisruptionEventsEnum_AsSpecifiedInConfirmation = "AsSpecifiedInConfirmation"
 
-- | The type of mark to market convention.
data MarkToMarketConventionEnum
    = MarkToMarketConventionEnum_Gross
    | MarkToMarketConventionEnum_Netted
    deriving (Eq,Show,Enum)
instance SchemaType MarkToMarketConventionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType MarkToMarketConventionEnum where
    acceptingParser =  do isWord "Gross"; return MarkToMarketConventionEnum_Gross
                      `onFail` do isWord "Netted"; return MarkToMarketConventionEnum_Netted
                      
    simpleTypeText MarkToMarketConventionEnum_Gross = "Gross"
    simpleTypeText MarkToMarketConventionEnum_Netted = "Netted"
 
-- | Defines how adjustments will be made to the contract should 
--   one or more of the extraordinary events occur.
data MethodOfAdjustmentEnum
    = MethodOfAdjustmentEnum_CalculationAgent
      -- ^ The Calculation Agent has the right to adjust the terms of 
      --   the trade following a corporate action.
    | MethodOfAdjustmentEnum_OptionsExchange
      -- ^ The trade will be adjusted in accordance with any 
      --   adjustment made by the exchange on which options on the 
      --   underlying are listed.
    deriving (Eq,Show,Enum)
instance SchemaType MethodOfAdjustmentEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType MethodOfAdjustmentEnum where
    acceptingParser =  do isWord "CalculationAgent"; return MethodOfAdjustmentEnum_CalculationAgent
                      `onFail` do isWord "OptionsExchange"; return MethodOfAdjustmentEnum_OptionsExchange
                      
    simpleTypeText MethodOfAdjustmentEnum_CalculationAgent = "CalculationAgent"
    simpleTypeText MethodOfAdjustmentEnum_OptionsExchange = "OptionsExchange"
 
-- | Defines the consequences of nationalisation, insolvency and 
--   delisting events relating to the underlying.
data NationalisationOrInsolvencyOrDelistingEventEnum
    = NationalisationOrInsolvencyOrDelistingEventEnum_NegotiatedCloseout
      -- ^ The parties may, but are not obliged, to terminate the 
      --   transaction on mutually acceptable terms and if the terms 
      --   are not agreed then the transaction continues.
    | NationalisationOrInsolvencyOrDelistingEventEnum_CancellationAndPayment
      -- ^ The trade is terminated.
    deriving (Eq,Show,Enum)
instance SchemaType NationalisationOrInsolvencyOrDelistingEventEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType NationalisationOrInsolvencyOrDelistingEventEnum where
    acceptingParser =  do isWord "NegotiatedCloseout"; return NationalisationOrInsolvencyOrDelistingEventEnum_NegotiatedCloseout
                      `onFail` do isWord "CancellationAndPayment"; return NationalisationOrInsolvencyOrDelistingEventEnum_CancellationAndPayment
                      
    simpleTypeText NationalisationOrInsolvencyOrDelistingEventEnum_NegotiatedCloseout = "NegotiatedCloseout"
    simpleTypeText NationalisationOrInsolvencyOrDelistingEventEnum_CancellationAndPayment = "CancellationAndPayment"
 
-- | The method of calculating payment obligations when a 
--   floating rate is negative (either due to a quoted negative 
--   floating rate or by operation of a spread that is 
--   subtracted from the floating rate).
data NegativeInterestRateTreatmentEnum
    = NegativeInterestRateTreatmentEnum_NegativeInterestRateMethod
      -- ^ Negative Interest Rate Method. Per 2000 ISDA Definitions, 
      --   Section 6.4 Negative Interest Rates, paragraphs (b) and 
      --   (c).
    | NegativeInterestRateTreatmentEnum_ZeroInterestRateMethod
      -- ^ Zero Interest Rate Method. Per 2000 ISDA Definitions, 
      --   Section 6.4. Negative Interest Rates, paragraphs (d) and 
      --   (e).
    deriving (Eq,Show,Enum)
instance SchemaType NegativeInterestRateTreatmentEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType NegativeInterestRateTreatmentEnum where
    acceptingParser =  do isWord "NegativeInterestRateMethod"; return NegativeInterestRateTreatmentEnum_NegativeInterestRateMethod
                      `onFail` do isWord "ZeroInterestRateMethod"; return NegativeInterestRateTreatmentEnum_ZeroInterestRateMethod
                      
    simpleTypeText NegativeInterestRateTreatmentEnum_NegativeInterestRateMethod = "NegativeInterestRateMethod"
    simpleTypeText NegativeInterestRateTreatmentEnum_ZeroInterestRateMethod = "ZeroInterestRateMethod"
 
-- | Defines treatment of non-cash dividends.
data NonCashDividendTreatmentEnum
    = NonCashDividendTreatmentEnum_PotentialAdjustmentEvent
      -- ^ The treatment of any non-cash dividend shall be determined 
      --   in accordance with the Potential Adjustment Event 
      --   provisions.
    | NonCashDividendTreatmentEnum_CashEquivalent
      -- ^ Any non-cash dividend shall be treated as a Declared Cash 
      --   Equivalent Dividend.
    deriving (Eq,Show,Enum)
instance SchemaType NonCashDividendTreatmentEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType NonCashDividendTreatmentEnum where
    acceptingParser =  do isWord "PotentialAdjustmentEvent"; return NonCashDividendTreatmentEnum_PotentialAdjustmentEvent
                      `onFail` do isWord "CashEquivalent"; return NonCashDividendTreatmentEnum_CashEquivalent
                      
    simpleTypeText NonCashDividendTreatmentEnum_PotentialAdjustmentEvent = "PotentialAdjustmentEvent"
    simpleTypeText NonCashDividendTreatmentEnum_CashEquivalent = "CashEquivalent"
 
-- | The conditions that govern the adjustment to the number of 
--   units of the equity swap.
data NotionalAdjustmentEnum
    = NotionalAdjustmentEnum_Execution
      -- ^ The adjustments to the number of units are governed by an 
      --   execution clause.
    | NotionalAdjustmentEnum_PortfolioRebalancing
      -- ^ The adjustments to the number of units are governed by a 
      --   portfolio rebalancing clause.
    | NotionalAdjustmentEnum_Standard
      -- ^ The adjustments to the number of units are not governed by 
      --   any specific clause.
    deriving (Eq,Show,Enum)
instance SchemaType NotionalAdjustmentEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType NotionalAdjustmentEnum where
    acceptingParser =  do isWord "Execution"; return NotionalAdjustmentEnum_Execution
                      `onFail` do isWord "PortfolioRebalancing"; return NotionalAdjustmentEnum_PortfolioRebalancing
                      `onFail` do isWord "Standard"; return NotionalAdjustmentEnum_Standard
                      
    simpleTypeText NotionalAdjustmentEnum_Execution = "Execution"
    simpleTypeText NotionalAdjustmentEnum_PortfolioRebalancing = "PortfolioRebalancing"
    simpleTypeText NotionalAdjustmentEnum_Standard = "Standard"
 
-- | Used in both the obligations and deliverable obligations of 
--   the credit default swap to represent a class or type of 
--   securities which apply.
data ObligationCategoryEnum
    = ObligationCategoryEnum_Payment
      -- ^ ISDA term "Payment".
    | ObligationCategoryEnum_BorrowedMoney
      -- ^ ISDA term "Borrowed Money".
    | ObligationCategoryEnum_ReferenceObligationsOnly
      -- ^ ISDA term "Reference Obligations Only".
    | ObligationCategoryEnum_Bond
      -- ^ ISDA term "Bond".
    | ObligationCategoryEnum_Loan
      -- ^ ISDA term "Loan".
    | ObligationCategoryEnum_BondOrLoan
      -- ^ ISDA term "Bond or Loan".
    deriving (Eq,Show,Enum)
instance SchemaType ObligationCategoryEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType ObligationCategoryEnum where
    acceptingParser =  do isWord "Payment"; return ObligationCategoryEnum_Payment
                      `onFail` do isWord "BorrowedMoney"; return ObligationCategoryEnum_BorrowedMoney
                      `onFail` do isWord "ReferenceObligationsOnly"; return ObligationCategoryEnum_ReferenceObligationsOnly
                      `onFail` do isWord "Bond"; return ObligationCategoryEnum_Bond
                      `onFail` do isWord "Loan"; return ObligationCategoryEnum_Loan
                      `onFail` do isWord "BondOrLoan"; return ObligationCategoryEnum_BondOrLoan
                      
    simpleTypeText ObligationCategoryEnum_Payment = "Payment"
    simpleTypeText ObligationCategoryEnum_BorrowedMoney = "BorrowedMoney"
    simpleTypeText ObligationCategoryEnum_ReferenceObligationsOnly = "ReferenceObligationsOnly"
    simpleTypeText ObligationCategoryEnum_Bond = "Bond"
    simpleTypeText ObligationCategoryEnum_Loan = "Loan"
    simpleTypeText ObligationCategoryEnum_BondOrLoan = "BondOrLoan"
 
-- | Specifies the type of the option.
data OptionTypeEnum
    = OptionTypeEnum_Put
      -- ^ A put option gives the holder the right to sell the 
      --   underlying asset by a certain date for a certain price.
    | OptionTypeEnum_Call
      -- ^ A call option gives the holder the right to buy the 
      --   underlying asset by a certain date for a certain price.
    | OptionTypeEnum_Payer
      -- ^ A "payer" option: If you buy a "payer" option you have the 
      --   right but not the obligation to enter into the underlying 
      --   swap transaction as the "fixed" rate/price payer and 
      --   receive float.
    | OptionTypeEnum_Receiver
      -- ^ A receiver option: If you buy a "receiver" option you have 
      --   the right but not the obligation to enter into the 
      --   underlying swap transaction as the "fixed" rate/price 
      --   receiver and pay float.
    | OptionTypeEnum_Straddle
      -- ^ A straddle strategy.
    deriving (Eq,Show,Enum)
instance SchemaType OptionTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType OptionTypeEnum where
    acceptingParser =  do isWord "Put"; return OptionTypeEnum_Put
                      `onFail` do isWord "Call"; return OptionTypeEnum_Call
                      `onFail` do isWord "Payer"; return OptionTypeEnum_Payer
                      `onFail` do isWord "Receiver"; return OptionTypeEnum_Receiver
                      `onFail` do isWord "Straddle"; return OptionTypeEnum_Straddle
                      
    simpleTypeText OptionTypeEnum_Put = "Put"
    simpleTypeText OptionTypeEnum_Call = "Call"
    simpleTypeText OptionTypeEnum_Payer = "Payer"
    simpleTypeText OptionTypeEnum_Receiver = "Receiver"
    simpleTypeText OptionTypeEnum_Straddle = "Straddle"
 
-- | The specification of an interest rate stream payer or 
--   receiver party.
data PayerReceiverEnum
    = PayerReceiverEnum_Payer
      -- ^ The party identified as the stream payer.
    | PayerReceiverEnum_Receiver
      -- ^ The party identified as the stream receiver.
    deriving (Eq,Show,Enum)
instance SchemaType PayerReceiverEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PayerReceiverEnum where
    acceptingParser =  do isWord "Payer"; return PayerReceiverEnum_Payer
                      `onFail` do isWord "Receiver"; return PayerReceiverEnum_Receiver
                      
    simpleTypeText PayerReceiverEnum_Payer = "Payer"
    simpleTypeText PayerReceiverEnum_Receiver = "Receiver"
 
-- | The specification of how an FX OTC option with a trigger 
--   payout will be paid if the trigger condition is met. The 
--   contract will specify whether the payout will occur 
--   immediately or on the original value date of the option.
data PayoutEnum
    = PayoutEnum_Deferred
      -- ^ If the trigger is hit, the option payout will not be paid 
      --   now but will be paid on the value date of the original 
      --   option.
    | PayoutEnum_Immediate
      -- ^ If the trigger is hit, the option payout will be paid 
      --   immediately (i.e., spot from the payout date).
    deriving (Eq,Show,Enum)
instance SchemaType PayoutEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PayoutEnum where
    acceptingParser =  do isWord "Deferred"; return PayoutEnum_Deferred
                      `onFail` do isWord "Immediate"; return PayoutEnum_Immediate
                      
    simpleTypeText PayoutEnum_Deferred = "Deferred"
    simpleTypeText PayoutEnum_Immediate = "Immediate"
 
-- | The specification of whether payments occur relative to the 
--   calculation period start or end date, or the reset date.
data PayRelativeToEnum
    = PayRelativeToEnum_CalculationPeriodStartDate
      -- ^ Payments will occur relative to the first day of each 
      --   calculation period.
    | PayRelativeToEnum_CalculationPeriodEndDate
      -- ^ Payments will occur relative to the last day of each 
      --   calculation period.
    | PayRelativeToEnum_LastPricingDate
      -- ^ Payments will occur relative to the last Pricing Date of 
      --   each Calculation Period.
    | PayRelativeToEnum_ResetDate
      -- ^ Payments will occur relative to the reset date.
    | PayRelativeToEnum_ValuationDate
      -- ^ Payments will occur relative to the valuation date.
    deriving (Eq,Show,Enum)
instance SchemaType PayRelativeToEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PayRelativeToEnum where
    acceptingParser =  do isWord "CalculationPeriodStartDate"; return PayRelativeToEnum_CalculationPeriodStartDate
                      `onFail` do isWord "CalculationPeriodEndDate"; return PayRelativeToEnum_CalculationPeriodEndDate
                      `onFail` do isWord "LastPricingDate"; return PayRelativeToEnum_LastPricingDate
                      `onFail` do isWord "ResetDate"; return PayRelativeToEnum_ResetDate
                      `onFail` do isWord "ValuationDate"; return PayRelativeToEnum_ValuationDate
                      
    simpleTypeText PayRelativeToEnum_CalculationPeriodStartDate = "CalculationPeriodStartDate"
    simpleTypeText PayRelativeToEnum_CalculationPeriodEndDate = "CalculationPeriodEndDate"
    simpleTypeText PayRelativeToEnum_LastPricingDate = "LastPricingDate"
    simpleTypeText PayRelativeToEnum_ResetDate = "ResetDate"
    simpleTypeText PayRelativeToEnum_ValuationDate = "ValuationDate"
 
-- | The specification of a time period
data PeriodEnum
    = PeriodEnum_D
      -- ^ Day.
    | PeriodEnum_W
      -- ^ Week.
    | PeriodEnum_M
      -- ^ Month.
    | PeriodEnum_Y
      -- ^ Year.
    deriving (Eq,Show,Enum)
instance SchemaType PeriodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PeriodEnum where
    acceptingParser =  do isWord "D"; return PeriodEnum_D
                      `onFail` do isWord "W"; return PeriodEnum_W
                      `onFail` do isWord "M"; return PeriodEnum_M
                      `onFail` do isWord "Y"; return PeriodEnum_Y
                      
    simpleTypeText PeriodEnum_D = "D"
    simpleTypeText PeriodEnum_W = "W"
    simpleTypeText PeriodEnum_M = "M"
    simpleTypeText PeriodEnum_Y = "Y"
 
-- | The specification of a time period containing additional 
--   values such as Term.
data PeriodExtendedEnum
    = PeriodExtendedEnum_D
      -- ^ Day.
    | PeriodExtendedEnum_W
      -- ^ Week.
    | PeriodExtendedEnum_M
      -- ^ Month.
    | PeriodExtendedEnum_Y
      -- ^ Year.
    | PeriodExtendedEnum_T
      -- ^ Term. The period commencing on the effective date and 
      --   ending on the termination date. The T period always appears 
      --   in association with periodMultiplier = 1, and the notation 
      --   is intended for use in contexts where the interval thus 
      --   qualified (e.g. accrual period, payment period, reset 
      --   period, ...) spans the entire term of the trade.
    deriving (Eq,Show,Enum)
instance SchemaType PeriodExtendedEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PeriodExtendedEnum where
    acceptingParser =  do isWord "D"; return PeriodExtendedEnum_D
                      `onFail` do isWord "W"; return PeriodExtendedEnum_W
                      `onFail` do isWord "M"; return PeriodExtendedEnum_M
                      `onFail` do isWord "Y"; return PeriodExtendedEnum_Y
                      `onFail` do isWord "T"; return PeriodExtendedEnum_T
                      
    simpleTypeText PeriodExtendedEnum_D = "D"
    simpleTypeText PeriodExtendedEnum_W = "W"
    simpleTypeText PeriodExtendedEnum_M = "M"
    simpleTypeText PeriodExtendedEnum_Y = "Y"
    simpleTypeText PeriodExtendedEnum_T = "T"
 
-- | A type used to report how a position originated.
data PositionOriginEnum
    = PositionOriginEnum_Trade
      -- ^ The position originated directly from a trade.
    | PositionOriginEnum_Allocation
      -- ^ The position originated from an allocation of a block 
      --   trade.
    | PositionOriginEnum_Novation
      -- ^ The position originated from a novation or post-trade 
      --   transfer.
    | PositionOriginEnum_Netting
      -- ^ The position originated from netting or portfolio 
      --   compression.
    | PositionOriginEnum_Exercise
      -- ^ The position originated from an exercise of a 
      --   physically-settled option.
    deriving (Eq,Show,Enum)
instance SchemaType PositionOriginEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PositionOriginEnum where
    acceptingParser =  do isWord "Trade"; return PositionOriginEnum_Trade
                      `onFail` do isWord "Allocation"; return PositionOriginEnum_Allocation
                      `onFail` do isWord "Novation"; return PositionOriginEnum_Novation
                      `onFail` do isWord "Netting"; return PositionOriginEnum_Netting
                      `onFail` do isWord "Exercise"; return PositionOriginEnum_Exercise
                      
    simpleTypeText PositionOriginEnum_Trade = "Trade"
    simpleTypeText PositionOriginEnum_Allocation = "Allocation"
    simpleTypeText PositionOriginEnum_Novation = "Novation"
    simpleTypeText PositionOriginEnum_Netting = "Netting"
    simpleTypeText PositionOriginEnum_Exercise = "Exercise"
 
data PositionStatusEnum
    = PositionStatusEnum_New
      -- ^ The position is open and has been newly added since the 
      --   last position report.
    | PositionStatusEnum_Existing
      -- ^ The position is open and was present in the last position 
      --   report.
    | PositionStatusEnum_Closed
      -- ^ The position is no longer open, for example because it has 
      --   matured, was assigned, or was terminated.
    deriving (Eq,Show,Enum)
instance SchemaType PositionStatusEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PositionStatusEnum where
    acceptingParser =  do isWord "New"; return PositionStatusEnum_New
                      `onFail` do isWord "Existing"; return PositionStatusEnum_Existing
                      `onFail` do isWord "Closed"; return PositionStatusEnum_Closed
                      
    simpleTypeText PositionStatusEnum_New = "New"
    simpleTypeText PositionStatusEnum_Existing = "Existing"
    simpleTypeText PositionStatusEnum_Closed = "Closed"
 
-- | The specification of how the premium for an FX OTC option 
--   is quoted.
data PremiumQuoteBasisEnum
    = PremiumQuoteBasisEnum_PercentageOfCallCurrencyAmount
      -- ^ Premium is quoted as a percentage of the 
      --   callCurrencyAmount.
    | PremiumQuoteBasisEnum_PercentageOfPutCurrencyAmount
      -- ^ Premium is quoted as a percentage of the putCurrencyAmount.
    | PremiumQuoteBasisEnum_CallCurrencyPerPutCurrency
      -- ^ Premium is quoted in the call currency as a percentage of 
      --   the put currency.
    | PremiumQuoteBasisEnum_PutCurrencyPerCallCurrency
      -- ^ Premium is quoted in the put currency as a percentage of 
      --   the call currency.
    | PremiumQuoteBasisEnum_Explicit
      -- ^ Premium is quoted as an explicit amount.
    deriving (Eq,Show,Enum)
instance SchemaType PremiumQuoteBasisEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PremiumQuoteBasisEnum where
    acceptingParser =  do isWord "PercentageOfCallCurrencyAmount"; return PremiumQuoteBasisEnum_PercentageOfCallCurrencyAmount
                      `onFail` do isWord "PercentageOfPutCurrencyAmount"; return PremiumQuoteBasisEnum_PercentageOfPutCurrencyAmount
                      `onFail` do isWord "CallCurrencyPerPutCurrency"; return PremiumQuoteBasisEnum_CallCurrencyPerPutCurrency
                      `onFail` do isWord "PutCurrencyPerCallCurrency"; return PremiumQuoteBasisEnum_PutCurrencyPerCallCurrency
                      `onFail` do isWord "Explicit"; return PremiumQuoteBasisEnum_Explicit
                      
    simpleTypeText PremiumQuoteBasisEnum_PercentageOfCallCurrencyAmount = "PercentageOfCallCurrencyAmount"
    simpleTypeText PremiumQuoteBasisEnum_PercentageOfPutCurrencyAmount = "PercentageOfPutCurrencyAmount"
    simpleTypeText PremiumQuoteBasisEnum_CallCurrencyPerPutCurrency = "CallCurrencyPerPutCurrency"
    simpleTypeText PremiumQuoteBasisEnum_PutCurrencyPerCallCurrency = "PutCurrencyPerCallCurrency"
    simpleTypeText PremiumQuoteBasisEnum_Explicit = "Explicit"
 
-- | Premium Type for Forward Start Equity Option
data PremiumTypeEnum
    = PremiumTypeEnum_PrePaid
      -- ^ TODO
    | PremiumTypeEnum_PostPaid
      -- ^ TODO
    | PremiumTypeEnum_Variable
      -- ^ TODO
    | PremiumTypeEnum_Fixed
      -- ^ TODO
    deriving (Eq,Show,Enum)
instance SchemaType PremiumTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PremiumTypeEnum where
    acceptingParser =  do isWord "PrePaid"; return PremiumTypeEnum_PrePaid
                      `onFail` do isWord "PostPaid"; return PremiumTypeEnum_PostPaid
                      `onFail` do isWord "Variable"; return PremiumTypeEnum_Variable
                      `onFail` do isWord "Fixed"; return PremiumTypeEnum_Fixed
                      
    simpleTypeText PremiumTypeEnum_PrePaid = "PrePaid"
    simpleTypeText PremiumTypeEnum_PostPaid = "PostPaid"
    simpleTypeText PremiumTypeEnum_Variable = "Variable"
    simpleTypeText PremiumTypeEnum_Fixed = "Fixed"
 
-- | The mode of expression of a price.
data PriceExpressionEnum
    = PriceExpressionEnum_AbsoluteTerms
      -- ^ The price is expressed as an absolute amount.&gt;
    | PriceExpressionEnum_PercentageOfNotional
      -- ^ The price is expressed in percentage of the notional 
      --   amount.
    deriving (Eq,Show,Enum)
instance SchemaType PriceExpressionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PriceExpressionEnum where
    acceptingParser =  do isWord "AbsoluteTerms"; return PriceExpressionEnum_AbsoluteTerms
                      `onFail` do isWord "PercentageOfNotional"; return PriceExpressionEnum_PercentageOfNotional
                      
    simpleTypeText PriceExpressionEnum_AbsoluteTerms = "AbsoluteTerms"
    simpleTypeText PriceExpressionEnum_PercentageOfNotional = "PercentageOfNotional"
 
-- | Specifies whether the option is a call or a put.
data PutCallEnum
    = PutCallEnum_Put
      -- ^ A put option gives the holder the right to sell the 
      --   underlying asset by a certain date for a certain price.
    | PutCallEnum_Call
      -- ^ A call option gives the holder the right to buy the 
      --   underlying asset by a certain date for a certain price.
    deriving (Eq,Show,Enum)
instance SchemaType PutCallEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType PutCallEnum where
    acceptingParser =  do isWord "Put"; return PutCallEnum_Put
                      `onFail` do isWord "Call"; return PutCallEnum_Call
                      
    simpleTypeText PutCallEnum_Put = "Put"
    simpleTypeText PutCallEnum_Call = "Call"
 
-- | The specification of the type of quotation rate to be 
--   obtained from each cash settlement reference bank.
data QuotationRateTypeEnum
    = QuotationRateTypeEnum_Bid
      -- ^ A bid rate.
    | QuotationRateTypeEnum_Ask
      -- ^ An ask rate.
    | QuotationRateTypeEnum_Mid
      -- ^ A mid-market rate.
    | QuotationRateTypeEnum_ExercisingPartyPays
      -- ^ If optional early termination is applicable to a swap 
      --   transaction, the rate, which may be a bid or ask rate, 
      --   which would result, if seller is in-the-money, in the 
      --   higher absolute value of the cash settlement amount, or, is 
      --   seller is out-of-the-money, in the lower absolute value of 
      --   the cash settlement amount.
    deriving (Eq,Show,Enum)
instance SchemaType QuotationRateTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType QuotationRateTypeEnum where
    acceptingParser =  do isWord "Bid"; return QuotationRateTypeEnum_Bid
                      `onFail` do isWord "Ask"; return QuotationRateTypeEnum_Ask
                      `onFail` do isWord "Mid"; return QuotationRateTypeEnum_Mid
                      `onFail` do isWord "ExercisingPartyPays"; return QuotationRateTypeEnum_ExercisingPartyPays
                      
    simpleTypeText QuotationRateTypeEnum_Bid = "Bid"
    simpleTypeText QuotationRateTypeEnum_Ask = "Ask"
    simpleTypeText QuotationRateTypeEnum_Mid = "Mid"
    simpleTypeText QuotationRateTypeEnum_ExercisingPartyPays = "ExercisingPartyPays"
 
-- | The side from which perspective a value is quoted.
data QuotationSideEnum
    = QuotationSideEnum_Bid
      -- ^ A value "bid" by a buyer for an asset, i.e. the value a 
      --   buyer is willing to pay.
    | QuotationSideEnum_Ask
      -- ^ A value "asked" by a seller for an asset, i.e. the value at 
      --   which a seller is willing to sell.
    | QuotationSideEnum_Mid
      -- ^ A value midway between the bid and the ask value.
    deriving (Eq,Show,Enum)
instance SchemaType QuotationSideEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType QuotationSideEnum where
    acceptingParser =  do isWord "Bid"; return QuotationSideEnum_Bid
                      `onFail` do isWord "Ask"; return QuotationSideEnum_Ask
                      `onFail` do isWord "Mid"; return QuotationSideEnum_Mid
                      
    simpleTypeText QuotationSideEnum_Bid = "Bid"
    simpleTypeText QuotationSideEnum_Ask = "Ask"
    simpleTypeText QuotationSideEnum_Mid = "Mid"
 
-- | Indicates the actual quotation style of of PointsUpFront or 
--   TradedSpread that was used to quote this trade.
data QuotationStyleEnum
    = QuotationStyleEnum_PointsUpFront
      -- ^ When quotation style is "PointsUpFront", the initialPoints 
      --   element of the feeLeg should be populated.
    | QuotationStyleEnum_TradedSpread
      -- ^ When quotation style is "TradedSpread", the marketFixedRate 
      --   element of the feeLeg should be populated.
    deriving (Eq,Show,Enum)
instance SchemaType QuotationStyleEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType QuotationStyleEnum where
    acceptingParser =  do isWord "PointsUpFront"; return QuotationStyleEnum_PointsUpFront
                      `onFail` do isWord "TradedSpread"; return QuotationStyleEnum_TradedSpread
                      
    simpleTypeText QuotationStyleEnum_PointsUpFront = "PointsUpFront"
    simpleTypeText QuotationStyleEnum_TradedSpread = "TradedSpread"
 
-- | How an exchange rate is quoted.
data QuoteBasisEnum
    = QuoteBasisEnum_Currency1PerCurrency2
      -- ^ The amount of currency1 for one unit of currency2
    | QuoteBasisEnum_Currency2PerCurrency1
      -- ^ The amount of currency2 for one unit of currency1
    deriving (Eq,Show,Enum)
instance SchemaType QuoteBasisEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType QuoteBasisEnum where
    acceptingParser =  do isWord "Currency1PerCurrency2"; return QuoteBasisEnum_Currency1PerCurrency2
                      `onFail` do isWord "Currency2PerCurrency1"; return QuoteBasisEnum_Currency2PerCurrency1
                      
    simpleTypeText QuoteBasisEnum_Currency1PerCurrency2 = "Currency1PerCurrency2"
    simpleTypeText QuoteBasisEnum_Currency2PerCurrency1 = "Currency2PerCurrency1"
 
-- | The specification of methods for converting rates from one 
--   basis to another.
data RateTreatmentEnum
    = RateTreatmentEnum_BondEquivalentYield
      -- ^ Bond Equivalent Yield. Per Annex to the 2000 ISDA 
      --   Definitions (June 2000 Version), Section 7.3. Certain 
      --   General Definitions Relating to Floating Rate Options, 
      --   paragraph (g).
    | RateTreatmentEnum_MoneyMarketYield
      -- ^ Money Market Yield. Per Annex to the 2000 ISDA Definitions 
      --   (June 2000 Version), Section 7.3. Certain General 
      --   Definitions Relating to Floating Rate Options, paragraph 
      --   (h).
    deriving (Eq,Show,Enum)
instance SchemaType RateTreatmentEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType RateTreatmentEnum where
    acceptingParser =  do isWord "BondEquivalentYield"; return RateTreatmentEnum_BondEquivalentYield
                      `onFail` do isWord "MoneyMarketYield"; return RateTreatmentEnum_MoneyMarketYield
                      
    simpleTypeText RateTreatmentEnum_BondEquivalentYield = "BondEquivalentYield"
    simpleTypeText RateTreatmentEnum_MoneyMarketYield = "MoneyMarketYield"
 
-- | The contract specifies whether which price must satisfy the 
--   boundary condition.
data RealisedVarianceMethodEnum
    = RealisedVarianceMethodEnum_Previous
      -- ^ For a return on day T, the observed price on T-1 must be in 
      --   range.
    | RealisedVarianceMethodEnum_Last
      -- ^ For a return on day T, the observed price on T must be in 
      --   range.
    | RealisedVarianceMethodEnum_Both
      -- ^ For a return on day T, the observed prices on both T and 
      --   T-1 must be in range
    deriving (Eq,Show,Enum)
instance SchemaType RealisedVarianceMethodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType RealisedVarianceMethodEnum where
    acceptingParser =  do isWord "Previous"; return RealisedVarianceMethodEnum_Previous
                      `onFail` do isWord "Last"; return RealisedVarianceMethodEnum_Last
                      `onFail` do isWord "Both"; return RealisedVarianceMethodEnum_Both
                      
    simpleTypeText RealisedVarianceMethodEnum_Previous = "Previous"
    simpleTypeText RealisedVarianceMethodEnum_Last = "Last"
    simpleTypeText RealisedVarianceMethodEnum_Both = "Both"
 
-- | The specification of whether resets occur relative to the 
--   first or last day of a calculation period.
data ResetRelativeToEnum
    = ResetRelativeToEnum_CalculationPeriodStartDate
      -- ^ Resets will occur relative to the first day of each 
      --   calculation period.
    | ResetRelativeToEnum_CalculationPeriodEndDate
      -- ^ Resets will occur relative to the last day of each 
      --   calculation period.
    deriving (Eq,Show,Enum)
instance SchemaType ResetRelativeToEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType ResetRelativeToEnum where
    acceptingParser =  do isWord "CalculationPeriodStartDate"; return ResetRelativeToEnum_CalculationPeriodStartDate
                      `onFail` do isWord "CalculationPeriodEndDate"; return ResetRelativeToEnum_CalculationPeriodEndDate
                      
    simpleTypeText ResetRelativeToEnum_CalculationPeriodStartDate = "CalculationPeriodStartDate"
    simpleTypeText ResetRelativeToEnum_CalculationPeriodEndDate = "CalculationPeriodEndDate"
 
-- | The type of return associated with the equity swap.
data ReturnTypeEnum
    = ReturnTypeEnum_Dividend
      -- ^ Dividend return swap.
    | ReturnTypeEnum_Price
      -- ^ Price return swap.
    | ReturnTypeEnum_Total
      -- ^ Total return swap.
    deriving (Eq,Show,Enum)
instance SchemaType ReturnTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType ReturnTypeEnum where
    acceptingParser =  do isWord "Dividend"; return ReturnTypeEnum_Dividend
                      `onFail` do isWord "Price"; return ReturnTypeEnum_Price
                      `onFail` do isWord "Total"; return ReturnTypeEnum_Total
                      
    simpleTypeText ReturnTypeEnum_Dividend = "Dividend"
    simpleTypeText ReturnTypeEnum_Price = "Price"
    simpleTypeText ReturnTypeEnum_Total = "Total"
 
-- | The convention for determining the sequence of calculation 
--   period end dates. It is used in conjunction with a 
--   specified frequency and the regular period start date of a 
--   calculation period, e.g. semi-annual IMM roll dates.
data RollConventionEnum
    = RollConventionEnum_EOM
      -- ^ Rolls on month end dates irrespective of the length of the 
      --   month and the previous roll day.
    | RollConventionEnum_FRN
      -- ^ Roll days are determined according to the FRN Convention or 
      --   Eurodollar Convention as described in ISDA 2000 
      --   definitions.
    | RollConventionEnum_IMM
      -- ^ IMM Settlement Dates. The third Wednesday of the (delivery) 
      --   month.
    | RollConventionEnum_IMMCAD
      -- ^ The last trading day/expiration day of the Canadian 
      --   Derivatives Exchange (Bourse de Montreal Inc) Three-month 
      --   Canadian Bankers' Acceptance Futures (Ticker Symbol BAX). 
      --   The second London banking day prior to the third Wednesday 
      --   of the contract month. If the determined day is a Bourse or 
      --   bank holiday in Montreal or Toronto, the last trading day 
      --   shall be the previous bank business day. Per Canadian 
      --   Derivatives Exchange BAX contract specification.
    | RollConventionEnum_IMMAUD
      -- ^ The last trading day of the Sydney Futures Exchange 90 Day 
      --   Bank Accepted Bills Futures contract (see 
      --   http://www.sfe.com.au/content/sfe/trading/con_specs.pdf). 
      --   One Sydney business day preceding the second Friday of the 
      --   relevant settlement month.
    | RollConventionEnum_IMMNZD
      -- ^ The last trading day of the Sydney Futures Exchange NZ 90 
      --   Day Bank Bill Futures contract (see 
      --   http://www.sfe.com.au/content/sfe/trading/con_specs.pdf). 
      --   The first Wednesday after the ninth day of the relevant 
      --   settlement month.
    | RollConventionEnum_SFE
      -- ^ Sydney Futures Exchange 90-Day Bank Accepted Bill Futures 
      --   Settlement Dates. The second Friday of the (delivery) 
      --   month.
    | RollConventionEnum_NONE
      -- ^ The roll convention is not required. For example, in the 
      --   case of a daily calculation frequency.
    | RollConventionEnum_TBILL
      -- ^ 13-week and 26-week U.S. Treasury Bill Auction Dates. Each 
      --   Monday except for U.S. (New York) holidays when it will 
      --   occur on a Tuesday.
    | RollConventionEnum_V1
      -- ^ Rolls on the 1st day of the month.
    | RollConventionEnum_V2
      -- ^ Rolls on the 2nd day of the month.
    | RollConventionEnum_V3
      -- ^ Rolls on the 3rd day of the month.
    | RollConventionEnum_V4
      -- ^ Rolls on the 4th day of the month.
    | RollConventionEnum_V5
      -- ^ Rolls on the 4th day of the month.
    | RollConventionEnum_V6
      -- ^ Rolls on the 6th day of the month.
    | RollConventionEnum_V7
      -- ^ Rolls on the 7th day of the month.
    | RollConventionEnum_V8
      -- ^ Rolls on the 8th day of the month.
    | RollConventionEnum_V9
      -- ^ Rolls on the 9th day of the month.
    | RollConventionEnum_V10
      -- ^ Rolls on the 10th day of the month.
    | RollConventionEnum_V11
      -- ^ Rolls on the 11th day of the month.
    | RollConventionEnum_V12
      -- ^ Rolls on the 12th day of the month.
    | RollConventionEnum_V13
      -- ^ Rolls on the 13th day of the month.
    | RollConventionEnum_V14
      -- ^ Rolls on the 14th day of the month.
    | RollConventionEnum_V15
      -- ^ Rolls on the 15th day of the month.
    | RollConventionEnum_V16
      -- ^ Rolls on the 16th day of the month.
    | RollConventionEnum_V17
      -- ^ Rolls on the 17th day of the month.
    | RollConventionEnum_V18
      -- ^ Rolls on the 18th day of the month.
    | RollConventionEnum_V19
      -- ^ Rolls on the 19th day of the month.
    | RollConventionEnum_V20
      -- ^ Rolls on the 20th day of the month.
    | RollConventionEnum_V21
      -- ^ Rolls on the 21st day of the month.
    | RollConventionEnum_V22
      -- ^ Rolls on the 22nd day of the month.
    | RollConventionEnum_V23
      -- ^ Rolls on the 23rd day of the month.
    | RollConventionEnum_V24
      -- ^ Rolls on the 24th day of the month.
    | RollConventionEnum_V25
      -- ^ Rolls on the 25th day of the month.
    | RollConventionEnum_V26
      -- ^ Rolls on the 26th day of the month.
    | RollConventionEnum_V27
      -- ^ Rolls on the 27th day of the month.
    | RollConventionEnum_V28
      -- ^ Rolls on the 28th day of the month.
    | RollConventionEnum_V29
      -- ^ Rolls on the 29th day of the month.
    | RollConventionEnum_V30
      -- ^ Rolls on the 30th day of the month.
    | RollConventionEnum_MON
      -- ^ Rolling weekly on a Monday.
    | RollConventionEnum_TUE
      -- ^ Rolling weekly on a Tuesday.
    | RollConventionEnum_WED
      -- ^ Rolling weekly on a Wednesday.
    | RollConventionEnum_THU
      -- ^ Rolling weekly on a Thursday.
    | RollConventionEnum_FRI
      -- ^ Rolling weekly on a Friday.
    | RollConventionEnum_SAT
      -- ^ Rolling weekly on a Saturday.
    | RollConventionEnum_SUN
      -- ^ Rolling weekly on a Sunday.
    deriving (Eq,Show,Enum)
instance SchemaType RollConventionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType RollConventionEnum where
    acceptingParser =  do isWord "EOM"; return RollConventionEnum_EOM
                      `onFail` do isWord "FRN"; return RollConventionEnum_FRN
                      `onFail` do isWord "IMM"; return RollConventionEnum_IMM
                      `onFail` do isWord "IMMCAD"; return RollConventionEnum_IMMCAD
                      `onFail` do isWord "IMMAUD"; return RollConventionEnum_IMMAUD
                      `onFail` do isWord "IMMNZD"; return RollConventionEnum_IMMNZD
                      `onFail` do isWord "SFE"; return RollConventionEnum_SFE
                      `onFail` do isWord "NONE"; return RollConventionEnum_NONE
                      `onFail` do isWord "TBILL"; return RollConventionEnum_TBILL
                      `onFail` do isWord "1"; return RollConventionEnum_V1
                      `onFail` do isWord "2"; return RollConventionEnum_V2
                      `onFail` do isWord "3"; return RollConventionEnum_V3
                      `onFail` do isWord "4"; return RollConventionEnum_V4
                      `onFail` do isWord "5"; return RollConventionEnum_V5
                      `onFail` do isWord "6"; return RollConventionEnum_V6
                      `onFail` do isWord "7"; return RollConventionEnum_V7
                      `onFail` do isWord "8"; return RollConventionEnum_V8
                      `onFail` do isWord "9"; return RollConventionEnum_V9
                      `onFail` do isWord "10"; return RollConventionEnum_V10
                      `onFail` do isWord "11"; return RollConventionEnum_V11
                      `onFail` do isWord "12"; return RollConventionEnum_V12
                      `onFail` do isWord "13"; return RollConventionEnum_V13
                      `onFail` do isWord "14"; return RollConventionEnum_V14
                      `onFail` do isWord "15"; return RollConventionEnum_V15
                      `onFail` do isWord "16"; return RollConventionEnum_V16
                      `onFail` do isWord "17"; return RollConventionEnum_V17
                      `onFail` do isWord "18"; return RollConventionEnum_V18
                      `onFail` do isWord "19"; return RollConventionEnum_V19
                      `onFail` do isWord "20"; return RollConventionEnum_V20
                      `onFail` do isWord "21"; return RollConventionEnum_V21
                      `onFail` do isWord "22"; return RollConventionEnum_V22
                      `onFail` do isWord "23"; return RollConventionEnum_V23
                      `onFail` do isWord "24"; return RollConventionEnum_V24
                      `onFail` do isWord "25"; return RollConventionEnum_V25
                      `onFail` do isWord "26"; return RollConventionEnum_V26
                      `onFail` do isWord "27"; return RollConventionEnum_V27
                      `onFail` do isWord "28"; return RollConventionEnum_V28
                      `onFail` do isWord "29"; return RollConventionEnum_V29
                      `onFail` do isWord "30"; return RollConventionEnum_V30
                      `onFail` do isWord "MON"; return RollConventionEnum_MON
                      `onFail` do isWord "TUE"; return RollConventionEnum_TUE
                      `onFail` do isWord "WED"; return RollConventionEnum_WED
                      `onFail` do isWord "THU"; return RollConventionEnum_THU
                      `onFail` do isWord "FRI"; return RollConventionEnum_FRI
                      `onFail` do isWord "SAT"; return RollConventionEnum_SAT
                      `onFail` do isWord "SUN"; return RollConventionEnum_SUN
                      
    simpleTypeText RollConventionEnum_EOM = "EOM"
    simpleTypeText RollConventionEnum_FRN = "FRN"
    simpleTypeText RollConventionEnum_IMM = "IMM"
    simpleTypeText RollConventionEnum_IMMCAD = "IMMCAD"
    simpleTypeText RollConventionEnum_IMMAUD = "IMMAUD"
    simpleTypeText RollConventionEnum_IMMNZD = "IMMNZD"
    simpleTypeText RollConventionEnum_SFE = "SFE"
    simpleTypeText RollConventionEnum_NONE = "NONE"
    simpleTypeText RollConventionEnum_TBILL = "TBILL"
    simpleTypeText RollConventionEnum_V1 = "1"
    simpleTypeText RollConventionEnum_V2 = "2"
    simpleTypeText RollConventionEnum_V3 = "3"
    simpleTypeText RollConventionEnum_V4 = "4"
    simpleTypeText RollConventionEnum_V5 = "5"
    simpleTypeText RollConventionEnum_V6 = "6"
    simpleTypeText RollConventionEnum_V7 = "7"
    simpleTypeText RollConventionEnum_V8 = "8"
    simpleTypeText RollConventionEnum_V9 = "9"
    simpleTypeText RollConventionEnum_V10 = "10"
    simpleTypeText RollConventionEnum_V11 = "11"
    simpleTypeText RollConventionEnum_V12 = "12"
    simpleTypeText RollConventionEnum_V13 = "13"
    simpleTypeText RollConventionEnum_V14 = "14"
    simpleTypeText RollConventionEnum_V15 = "15"
    simpleTypeText RollConventionEnum_V16 = "16"
    simpleTypeText RollConventionEnum_V17 = "17"
    simpleTypeText RollConventionEnum_V18 = "18"
    simpleTypeText RollConventionEnum_V19 = "19"
    simpleTypeText RollConventionEnum_V20 = "20"
    simpleTypeText RollConventionEnum_V21 = "21"
    simpleTypeText RollConventionEnum_V22 = "22"
    simpleTypeText RollConventionEnum_V23 = "23"
    simpleTypeText RollConventionEnum_V24 = "24"
    simpleTypeText RollConventionEnum_V25 = "25"
    simpleTypeText RollConventionEnum_V26 = "26"
    simpleTypeText RollConventionEnum_V27 = "27"
    simpleTypeText RollConventionEnum_V28 = "28"
    simpleTypeText RollConventionEnum_V29 = "29"
    simpleTypeText RollConventionEnum_V30 = "30"
    simpleTypeText RollConventionEnum_MON = "MON"
    simpleTypeText RollConventionEnum_TUE = "TUE"
    simpleTypeText RollConventionEnum_WED = "WED"
    simpleTypeText RollConventionEnum_THU = "THU"
    simpleTypeText RollConventionEnum_FRI = "FRI"
    simpleTypeText RollConventionEnum_SAT = "SAT"
    simpleTypeText RollConventionEnum_SUN = "SUN"
 
-- | The method of rounding a fractional number.
data RoundingDirectionEnum
    = RoundingDirectionEnum_Up
      -- ^ A fractional number will be rounded up to the specified 
      --   number of decimal places (the precision). For example, 5.21 
      --   and 5.25 rounded up to 1 decimal place are 5.3 and 5.3 
      --   respectively.
    | RoundingDirectionEnum_Down
      -- ^ A fractional number will be rounded down to the specified 
      --   number of decimal places (the precision). For example, 5.29 
      --   and 5.25 rounded down to 1 decimal place are 5.2 and 5.2 
      --   respectively.
    | RoundingDirectionEnum_Nearest
      -- ^ A fractional number will be rounded either up or down to 
      --   the specified number of decimal places (the precision) 
      --   depending on its value. For example, 5.24 would be rounded 
      --   down to 5.2 and 5.25 would be rounded up to 5.3 if a 
      --   precision of 1 decimal place were specified.
    deriving (Eq,Show,Enum)
instance SchemaType RoundingDirectionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType RoundingDirectionEnum where
    acceptingParser =  do isWord "Up"; return RoundingDirectionEnum_Up
                      `onFail` do isWord "Down"; return RoundingDirectionEnum_Down
                      `onFail` do isWord "Nearest"; return RoundingDirectionEnum_Nearest
                      
    simpleTypeText RoundingDirectionEnum_Up = "Up"
    simpleTypeText RoundingDirectionEnum_Down = "Down"
    simpleTypeText RoundingDirectionEnum_Nearest = "Nearest"
 
-- | Defines the Settlement Period Duration for an Electricity 
--   Transaction.
data SettlementPeriodDurationEnum
    = SettlementPeriodDurationEnum_V2Hours
      -- ^ Two-hourly duration applies.
    | SettlementPeriodDurationEnum_V1Hour
      -- ^ Hourly duration applies.
    | SettlementPeriodDurationEnum_V30Minutes
      -- ^ Half-hourly duration applies.
    | SettlementPeriodDurationEnum_V15Minutes
      -- ^ Quarter-hourly duration applies.
    deriving (Eq,Show,Enum)
instance SchemaType SettlementPeriodDurationEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType SettlementPeriodDurationEnum where
    acceptingParser =  do isWord "2Hours"; return SettlementPeriodDurationEnum_V2Hours
                      `onFail` do isWord "1Hour"; return SettlementPeriodDurationEnum_V1Hour
                      `onFail` do isWord "30Minutes"; return SettlementPeriodDurationEnum_V30Minutes
                      `onFail` do isWord "15Minutes"; return SettlementPeriodDurationEnum_V15Minutes
                      
    simpleTypeText SettlementPeriodDurationEnum_V2Hours = "2Hours"
    simpleTypeText SettlementPeriodDurationEnum_V1Hour = "1Hour"
    simpleTypeText SettlementPeriodDurationEnum_V30Minutes = "30Minutes"
    simpleTypeText SettlementPeriodDurationEnum_V15Minutes = "15Minutes"
 
-- | Shows how the transaction is to be settled when it is 
--   exercised.
data SettlementTypeEnum
    = SettlementTypeEnum_Cash
      -- ^ The intrinsic value of the option will be delivered by way 
      --   of a cash settlement amount determined, (i) by reference to 
      --   the differential between the strike price and the 
      --   settlement price; or (ii) in accordance with a bilateral 
      --   agreement between the parties
    | SettlementTypeEnum_Physical
      -- ^ The securities underlying the transaction will be delivered 
      --   by (i) in the case of a call, the seller to the buyer, or 
      --   (ii) in the case of a put, the buyer to the seller versus a 
      --   settlement amount equivalent to the strike price per share
    | SettlementTypeEnum_Election
      -- ^ Allow Election of either Cash or Physical settlement
    deriving (Eq,Show,Enum)
instance SchemaType SettlementTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType SettlementTypeEnum where
    acceptingParser =  do isWord "Cash"; return SettlementTypeEnum_Cash
                      `onFail` do isWord "Physical"; return SettlementTypeEnum_Physical
                      `onFail` do isWord "Election"; return SettlementTypeEnum_Election
                      
    simpleTypeText SettlementTypeEnum_Cash = "Cash"
    simpleTypeText SettlementTypeEnum_Physical = "Physical"
    simpleTypeText SettlementTypeEnum_Election = "Election"
 
-- | Defines the consequences of extraordinary events relating 
--   to the underlying.
data ShareExtraordinaryEventEnum
    = ShareExtraordinaryEventEnum_AlternativeObligation
      -- ^ The trade continues such that the underlying now consists 
      --   of the New Shares and/or the Other Consideration, if any, 
      --   and the proceeds of any redemption, if any, that the holder 
      --   of the underlying Shares would have been entitled to.
    | ShareExtraordinaryEventEnum_CancellationAndPayment
      -- ^ The trade is cancelled and a cancellation fee will be paid 
      --   by one party to the other.
    | ShareExtraordinaryEventEnum_OptionsExchange
      -- ^ The trade will be adjusted by the Calculation Agent in 
      --   accordance with the adjustments made by any exchange on 
      --   which options on the underlying are listed.
    | ShareExtraordinaryEventEnum_CalculationAgent
      -- ^ The Calculation Agent will determine what adjustment is 
      --   required to offset any change to the economics of the 
      --   trade. If the Calculation Agent cannot achieve this, the 
      --   trade goes to Cancellation and Payment with the Calculation 
      --   Agent deciding on the value of the cancellation fee. 
      --   Adjustments may not be made to account solely for changes 
      --   in volatility, expected dividends, stock loan rate or 
      --   liquidity.
    | ShareExtraordinaryEventEnum_ModifiedCalculationAgent
      -- ^ The Calculation Agent will determine what adjustment is 
      --   required to offset any change to the economics of the 
      --   trade. If the Calculation Agent cannot achieve this, the 
      --   trade goes to Cancellation and Payment with the Calculation 
      --   Agent deciding on the value of the cancellation fee. 
      --   Adjustments to account for changes in volatility, expected 
      --   dividends, stock loan rate or liquidity are allowed.
    | ShareExtraordinaryEventEnum_PartialCancellationAndPayment
      -- ^ Applies to Basket Transactions. The portion of the Basket 
      --   made up by the affected Share will be cancelled and a 
      --   cancellation fee will be paid from one party to the other. 
      --   The remainder of the trade continues.
    | ShareExtraordinaryEventEnum_Component
      -- ^ If this is a Share-for-Combined merger event (Shares are 
      --   replaced with New Shares and Other Consideration), then 
      --   different treatment can be applied to each component if the 
      --   parties have specified this.
    deriving (Eq,Show,Enum)
instance SchemaType ShareExtraordinaryEventEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType ShareExtraordinaryEventEnum where
    acceptingParser =  do isWord "AlternativeObligation"; return ShareExtraordinaryEventEnum_AlternativeObligation
                      `onFail` do isWord "CancellationAndPayment"; return ShareExtraordinaryEventEnum_CancellationAndPayment
                      `onFail` do isWord "OptionsExchange"; return ShareExtraordinaryEventEnum_OptionsExchange
                      `onFail` do isWord "CalculationAgent"; return ShareExtraordinaryEventEnum_CalculationAgent
                      `onFail` do isWord "ModifiedCalculationAgent"; return ShareExtraordinaryEventEnum_ModifiedCalculationAgent
                      `onFail` do isWord "PartialCancellationAndPayment"; return ShareExtraordinaryEventEnum_PartialCancellationAndPayment
                      `onFail` do isWord "Component"; return ShareExtraordinaryEventEnum_Component
                      
    simpleTypeText ShareExtraordinaryEventEnum_AlternativeObligation = "AlternativeObligation"
    simpleTypeText ShareExtraordinaryEventEnum_CancellationAndPayment = "CancellationAndPayment"
    simpleTypeText ShareExtraordinaryEventEnum_OptionsExchange = "OptionsExchange"
    simpleTypeText ShareExtraordinaryEventEnum_CalculationAgent = "CalculationAgent"
    simpleTypeText ShareExtraordinaryEventEnum_ModifiedCalculationAgent = "ModifiedCalculationAgent"
    simpleTypeText ShareExtraordinaryEventEnum_PartialCancellationAndPayment = "PartialCancellationAndPayment"
    simpleTypeText ShareExtraordinaryEventEnum_Component = "Component"
 
-- | The Specified Price in respect of a Transaction and a 
--   Commodity Reference Price.
data SpecifiedPriceEnum
    = SpecifiedPriceEnum_Afternoon
      -- ^ The Specified Price shall be the Afternoon fixing reported 
      --   in or by the relevant Price Source as specified in the 
      --   relevant Confirmation.
    | SpecifiedPriceEnum_Ask
      -- ^ The Specified Price shall be the Ask price reported in or 
      --   by the relevant Price Source as specified in the relevant 
      --   Confirmation.
    | SpecifiedPriceEnum_Bid
      -- ^ The Specified Price shall be the Bid price reported in or 
      --   by the relevant Price Source as specified in the relevant 
      --   Confirmation.
    | SpecifiedPriceEnum_Closing
      -- ^ The Specified Price shall be the Closing price reported in 
      --   or by the relevant Price Source as specified in the 
      --   relevant Confirmation.
    | SpecifiedPriceEnum_High
      -- ^ The Specified Price shall be the High price reported in or 
      --   by the relevant Price Source as specified in the relevant 
      --   Confirmation.
    | SpecifiedPriceEnum_Index
      -- ^ The Specified Price shall be the Index price reported in or 
      --   by the relevant Price Source as specified in the relevant 
      --   Confirmation.
    | SpecifiedPriceEnum_MeanOfBidAndAsk
      -- ^ The Specified Price shall be the Average of the Bid and Ask 
      --   prices reported in or by the relevant Price Source as 
      --   specified in the relevant Confirmation.
    | SpecifiedPriceEnum_Low
      -- ^ The Specified Price shall be the Low price reported in or 
      --   by the relevant Price Source as specified in the relevant 
      --   Confirmation.
    | SpecifiedPriceEnum_MeanOfHighAndLow
      -- ^ The Specified Price shall be the Average of the High and 
      --   Low prices reported in or by the relevant Price Source as 
      --   specified in the relevant Confirmation.
    | SpecifiedPriceEnum_Morning
      -- ^ The Specified Price shall be the Morning fixing reported in 
      --   or by the relevant Price Source as specified in the 
      --   relevant Confirmation.
    | SpecifiedPriceEnum_Official
      -- ^ The Specified Price shall be the Official price reported in 
      --   or by the relevant Price Source as specified in the 
      --   relevant Confirmation.
    | SpecifiedPriceEnum_Opening
      -- ^ The Specified Price shall be the Opening price reported in 
      --   or by the relevant Price Source as specified in the 
      --   relevant Confirmation.
    | SpecifiedPriceEnum_OSP
      -- ^ The Specified Price shall be the Official Settlement Price 
      --   reported in or by the relevant Price Source as specified in 
      --   the relevant Confirmation.
    | SpecifiedPriceEnum_Settlement
      -- ^ The Specified Price shall be the Settlement price reported 
      --   in or by the relevant Price Source as specified in the 
      --   relevant Confirmation.
    | SpecifiedPriceEnum_Spot
      -- ^ The Specified Price shall be the Spot price reported in or 
      --   by the relevant Price Source as specified in the relevant 
      --   Confirmation.
    | SpecifiedPriceEnum_Midpoint
      -- ^ The Specified Price shall be the Average of the Midpoint of 
      --   prices reported in or by the relevant Price Source as 
      --   specified in the relevant Confirmation.
    | SpecifiedPriceEnum_WeightedAverage
      -- ^ The Specified Price shall be the volume Weighted Average of 
      --   prices effective on the Pricing Date reported in or by the 
      --   relevant Price Source as specified.
    deriving (Eq,Show,Enum)
instance SchemaType SpecifiedPriceEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType SpecifiedPriceEnum where
    acceptingParser =  do isWord "Afternoon"; return SpecifiedPriceEnum_Afternoon
                      `onFail` do isWord "Ask"; return SpecifiedPriceEnum_Ask
                      `onFail` do isWord "Bid"; return SpecifiedPriceEnum_Bid
                      `onFail` do isWord "Closing"; return SpecifiedPriceEnum_Closing
                      `onFail` do isWord "High"; return SpecifiedPriceEnum_High
                      `onFail` do isWord "Index"; return SpecifiedPriceEnum_Index
                      `onFail` do isWord "MeanOfBidAndAsk"; return SpecifiedPriceEnum_MeanOfBidAndAsk
                      `onFail` do isWord "Low"; return SpecifiedPriceEnum_Low
                      `onFail` do isWord "MeanOfHighAndLow"; return SpecifiedPriceEnum_MeanOfHighAndLow
                      `onFail` do isWord "Morning"; return SpecifiedPriceEnum_Morning
                      `onFail` do isWord "Official"; return SpecifiedPriceEnum_Official
                      `onFail` do isWord "Opening"; return SpecifiedPriceEnum_Opening
                      `onFail` do isWord "OSP"; return SpecifiedPriceEnum_OSP
                      `onFail` do isWord "Settlement"; return SpecifiedPriceEnum_Settlement
                      `onFail` do isWord "Spot"; return SpecifiedPriceEnum_Spot
                      `onFail` do isWord "Midpoint"; return SpecifiedPriceEnum_Midpoint
                      `onFail` do isWord "WeightedAverage"; return SpecifiedPriceEnum_WeightedAverage
                      
    simpleTypeText SpecifiedPriceEnum_Afternoon = "Afternoon"
    simpleTypeText SpecifiedPriceEnum_Ask = "Ask"
    simpleTypeText SpecifiedPriceEnum_Bid = "Bid"
    simpleTypeText SpecifiedPriceEnum_Closing = "Closing"
    simpleTypeText SpecifiedPriceEnum_High = "High"
    simpleTypeText SpecifiedPriceEnum_Index = "Index"
    simpleTypeText SpecifiedPriceEnum_MeanOfBidAndAsk = "MeanOfBidAndAsk"
    simpleTypeText SpecifiedPriceEnum_Low = "Low"
    simpleTypeText SpecifiedPriceEnum_MeanOfHighAndLow = "MeanOfHighAndLow"
    simpleTypeText SpecifiedPriceEnum_Morning = "Morning"
    simpleTypeText SpecifiedPriceEnum_Official = "Official"
    simpleTypeText SpecifiedPriceEnum_Opening = "Opening"
    simpleTypeText SpecifiedPriceEnum_OSP = "OSP"
    simpleTypeText SpecifiedPriceEnum_Settlement = "Settlement"
    simpleTypeText SpecifiedPriceEnum_Spot = "Spot"
    simpleTypeText SpecifiedPriceEnum_Midpoint = "Midpoint"
    simpleTypeText SpecifiedPriceEnum_WeightedAverage = "WeightedAverage"
 
-- | The code specification of whether a trade is settling using 
--   standard settlement instructions as well as whether it is a 
--   candidate for settlement netting.
data StandardSettlementStyleEnum
    = StandardSettlementStyleEnum_Standard
      -- ^ This trade will settle using standard pre-determined funds 
      --   settlement instructions.
    | StandardSettlementStyleEnum_Net
      -- ^ This trade is a candidate for settlement netting.
    | StandardSettlementStyleEnum_StandardAndNet
      -- ^ This trade will settle using standard pre-determined funds 
      --   settlement instructions and is a candidate for settlement 
      --   netting.
    deriving (Eq,Show,Enum)
instance SchemaType StandardSettlementStyleEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType StandardSettlementStyleEnum where
    acceptingParser =  do isWord "Standard"; return StandardSettlementStyleEnum_Standard
                      `onFail` do isWord "Net"; return StandardSettlementStyleEnum_Net
                      `onFail` do isWord "StandardAndNet"; return StandardSettlementStyleEnum_StandardAndNet
                      
    simpleTypeText StandardSettlementStyleEnum_Standard = "Standard"
    simpleTypeText StandardSettlementStyleEnum_Net = "Net"
    simpleTypeText StandardSettlementStyleEnum_StandardAndNet = "StandardAndNet"
 
-- | The specification of whether a percentage rate change, used 
--   to calculate a change in notional outstanding, is expressed 
--   as a percentage of the initial notional amount or the 
--   previously outstanding notional amount.
data StepRelativeToEnum
    = StepRelativeToEnum_Initial
      -- ^ Change in notional to be applied is calculated by 
      --   multiplying the percentage rate by the initial notional 
      --   amount.
    | StepRelativeToEnum_Previous
      -- ^ Change in notional to be applied is calculated by 
      --   multiplying the percentage rate by the previously 
      --   outstanding notional amount.
    deriving (Eq,Show,Enum)
instance SchemaType StepRelativeToEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType StepRelativeToEnum where
    acceptingParser =  do isWord "Initial"; return StepRelativeToEnum_Initial
                      `onFail` do isWord "Previous"; return StepRelativeToEnum_Previous
                      
    simpleTypeText StepRelativeToEnum_Initial = "Initial"
    simpleTypeText StepRelativeToEnum_Previous = "Previous"
 
-- | Element to define how to deal with a none standard 
--   calculation period within a swap stream.
data StubPeriodTypeEnum
    = StubPeriodTypeEnum_ShortInitial
      -- ^ If there is a non regular period remaining it is left 
      --   shorter than the streams calculation period frequency and 
      --   placed at the start of the stream
    | StubPeriodTypeEnum_ShortFinal
      -- ^ If there is a non regular period remaining it is left 
      --   shorter than the streams calculation period frequency and 
      --   placed at the end of the stream
    | StubPeriodTypeEnum_LongInitial
      -- ^ If there is a non regular period remaining it is placed at 
      --   the start of the stream and combined with the adjacent 
      --   calculation period to give a long first calculation period
    | StubPeriodTypeEnum_LongFinal
      -- ^ If there is a non regular period remaining it is placed at 
      --   the end of the stream and combined with the adjacent 
      --   calculation period to give a long last calculation period
    deriving (Eq,Show,Enum)
instance SchemaType StubPeriodTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType StubPeriodTypeEnum where
    acceptingParser =  do isWord "ShortInitial"; return StubPeriodTypeEnum_ShortInitial
                      `onFail` do isWord "ShortFinal"; return StubPeriodTypeEnum_ShortFinal
                      `onFail` do isWord "LongInitial"; return StubPeriodTypeEnum_LongInitial
                      `onFail` do isWord "LongFinal"; return StubPeriodTypeEnum_LongFinal
                      
    simpleTypeText StubPeriodTypeEnum_ShortInitial = "ShortInitial"
    simpleTypeText StubPeriodTypeEnum_ShortFinal = "ShortFinal"
    simpleTypeText StubPeriodTypeEnum_LongInitial = "LongInitial"
    simpleTypeText StubPeriodTypeEnum_LongFinal = "LongFinal"
 
-- | The specification of how an FX OTC option strike price is 
--   quoted.
data StrikeQuoteBasisEnum
    = StrikeQuoteBasisEnum_PutCurrencyPerCallCurrency
      -- ^ The strike price is an amount of putCurrency per one unit 
      --   of callCurrency.
    | StrikeQuoteBasisEnum_CallCurrencyPerPutCurrency
      -- ^ The strike price is an amount of callCurrency per one unit 
      --   of putCurrency.
    deriving (Eq,Show,Enum)
instance SchemaType StrikeQuoteBasisEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType StrikeQuoteBasisEnum where
    acceptingParser =  do isWord "PutCurrencyPerCallCurrency"; return StrikeQuoteBasisEnum_PutCurrencyPerCallCurrency
                      `onFail` do isWord "CallCurrencyPerPutCurrency"; return StrikeQuoteBasisEnum_CallCurrencyPerPutCurrency
                      
    simpleTypeText StrikeQuoteBasisEnum_PutCurrencyPerCallCurrency = "PutCurrencyPerCallCurrency"
    simpleTypeText StrikeQuoteBasisEnum_CallCurrencyPerPutCurrency = "CallCurrencyPerPutCurrency"
 
-- | The type of threshold.
data ThresholdTypeEnum
    = ThresholdTypeEnum_Secured
    | ThresholdTypeEnum_Unsecured
    deriving (Eq,Show,Enum)
instance SchemaType ThresholdTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType ThresholdTypeEnum where
    acceptingParser =  do isWord "Secured"; return ThresholdTypeEnum_Secured
                      `onFail` do isWord "Unsecured"; return ThresholdTypeEnum_Unsecured
                      
    simpleTypeText ThresholdTypeEnum_Secured = "Secured"
    simpleTypeText ThresholdTypeEnum_Unsecured = "Unsecured"
 
-- | Defines points in the day when equity option exercise and 
--   valuation can occur.
data TimeTypeEnum
    = TimeTypeEnum_Close
      -- ^ The official closing time of the exchange on the valuation 
      --   date.
    | TimeTypeEnum_Open
      -- ^ The official opening time of the exchange on the valuation 
      --   date.
    | TimeTypeEnum_OSP
      -- ^ The time at which the official settlement price is 
      --   determined.
    | TimeTypeEnum_SpecificTime
      -- ^ The time specified in the element equityExpirationTime or 
      --   valuationTime (as appropriate)
    | TimeTypeEnum_XETRA
      -- ^ The time at which the official settlement price (following 
      --   the auction by the exchange) is determined by the exchange.
    | TimeTypeEnum_DerivativesClose
      -- ^ The official closing time of the derivatives exchange on 
      --   which a derivative contract is listed on that security 
      --   underlyer.
    | TimeTypeEnum_AsSpecifiedInMasterConfirmation
      -- ^ The time is determined as provided in the relevant Master 
      --   Confirmation.
    deriving (Eq,Show,Enum)
instance SchemaType TimeTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType TimeTypeEnum where
    acceptingParser =  do isWord "Close"; return TimeTypeEnum_Close
                      `onFail` do isWord "Open"; return TimeTypeEnum_Open
                      `onFail` do isWord "OSP"; return TimeTypeEnum_OSP
                      `onFail` do isWord "SpecificTime"; return TimeTypeEnum_SpecificTime
                      `onFail` do isWord "XETRA"; return TimeTypeEnum_XETRA
                      `onFail` do isWord "DerivativesClose"; return TimeTypeEnum_DerivativesClose
                      `onFail` do isWord "AsSpecifiedInMasterConfirmation"; return TimeTypeEnum_AsSpecifiedInMasterConfirmation
                      
    simpleTypeText TimeTypeEnum_Close = "Close"
    simpleTypeText TimeTypeEnum_Open = "Open"
    simpleTypeText TimeTypeEnum_OSP = "OSP"
    simpleTypeText TimeTypeEnum_SpecificTime = "SpecificTime"
    simpleTypeText TimeTypeEnum_XETRA = "XETRA"
    simpleTypeText TimeTypeEnum_DerivativesClose = "DerivativesClose"
    simpleTypeText TimeTypeEnum_AsSpecifiedInMasterConfirmation = "AsSpecifiedInMasterConfirmation"
 
-- | The time of day which would be considered for valuing the 
--   knock event.
data TriggerTimeTypeEnum
    = TriggerTimeTypeEnum_Closing
      -- ^ The close of trading on a day would be considered for 
      --   valuation.
    | TriggerTimeTypeEnum_Anytime
      -- ^ At any time during the Knock Determination period 
      --   (continuous barrier).
    deriving (Eq,Show,Enum)
instance SchemaType TriggerTimeTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType TriggerTimeTypeEnum where
    acceptingParser =  do isWord "Closing"; return TriggerTimeTypeEnum_Closing
                      `onFail` do isWord "Anytime"; return TriggerTimeTypeEnum_Anytime
                      
    simpleTypeText TriggerTimeTypeEnum_Closing = "Closing"
    simpleTypeText TriggerTimeTypeEnum_Anytime = "Anytime"
 
-- | The specification of whether an option would trigger or 
--   expire depending upon whether the spot rate is above or 
--   below the barrier rate.
data TriggerTypeEnum
    = TriggerTypeEnum_EqualOrLess
      -- ^ The underlyer price must be equal to or less than the 
      --   Trigger level.
    | TriggerTypeEnum_EqualOrGreater
      -- ^ The underlyer price must be equal to or greater than the 
      --   Trigger level.
    | TriggerTypeEnum_Equal
      -- ^ The underlyer price must be equal to the Trigger level.
    | TriggerTypeEnum_Less
      -- ^ The underlyer price must be less than the Trigger level.
    | TriggerTypeEnum_Greater
      -- ^ The underlyer price must be greater than the Trigger level.
    deriving (Eq,Show,Enum)
instance SchemaType TriggerTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType TriggerTypeEnum where
    acceptingParser =  do isWord "EqualOrLess"; return TriggerTypeEnum_EqualOrLess
                      `onFail` do isWord "EqualOrGreater"; return TriggerTypeEnum_EqualOrGreater
                      `onFail` do isWord "Equal"; return TriggerTypeEnum_Equal
                      `onFail` do isWord "Less"; return TriggerTypeEnum_Less
                      `onFail` do isWord "Greater"; return TriggerTypeEnum_Greater
                      
    simpleTypeText TriggerTypeEnum_EqualOrLess = "EqualOrLess"
    simpleTypeText TriggerTypeEnum_EqualOrGreater = "EqualOrGreater"
    simpleTypeText TriggerTypeEnum_Equal = "Equal"
    simpleTypeText TriggerTypeEnum_Less = "Less"
    simpleTypeText TriggerTypeEnum_Greater = "Greater"
 
-- | The specification of, for American-style digitals, whether 
--   the trigger level must be touched or not touched.
data TouchConditionEnum
    = TouchConditionEnum_Touch
      -- ^ The spot rate must have touched the predetermined trigger 
      --   rate at any time over the life of the option for the payout 
      --   to occur.
    | TouchConditionEnum_Notouch
      -- ^ The spot rate has not touched the predetermined trigger 
      --   rate at any time over the life of the option for the payout 
      --   to occur.
    deriving (Eq,Show,Enum)
instance SchemaType TouchConditionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType TouchConditionEnum where
    acceptingParser =  do isWord "Touch"; return TouchConditionEnum_Touch
                      `onFail` do isWord "Notouch"; return TouchConditionEnum_Notouch
                      
    simpleTypeText TouchConditionEnum_Touch = "Touch"
    simpleTypeText TouchConditionEnum_Notouch = "Notouch"
 
-- | The specification of whether a payout will occur on an 
--   option depending upon whether the spot rate is above or 
--   below the trigger rate.
data TriggerConditionEnum
    = TriggerConditionEnum_Above
      -- ^ The spot rate must be greater than or equal to the trigger 
      --   rate.
    | TriggerConditionEnum_Below
      -- ^ The spot rate must be less than or equal to the trigger 
      --   rate.
    deriving (Eq,Show,Enum)
instance SchemaType TriggerConditionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType TriggerConditionEnum where
    acceptingParser =  do isWord "Above"; return TriggerConditionEnum_Above
                      `onFail` do isWord "Below"; return TriggerConditionEnum_Below
                      
    simpleTypeText TriggerConditionEnum_Above = "Above"
    simpleTypeText TriggerConditionEnum_Below = "Below"
 
-- | The ISDA defined methodology for determining the final 
--   price of the reference obligation for purposes of cash 
--   settlement.
data ValuationMethodEnum
    = ValuationMethodEnum_Market
    | ValuationMethodEnum_Highest
    | ValuationMethodEnum_AverageMarket
    | ValuationMethodEnum_AverageHighest
    | ValuationMethodEnum_BlendedMarket
    | ValuationMethodEnum_BlendedHighest
    | ValuationMethodEnum_AverageBlendedMarket
    | ValuationMethodEnum_AverageBlendedHighest
    deriving (Eq,Show,Enum)
instance SchemaType ValuationMethodEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType ValuationMethodEnum where
    acceptingParser =  do isWord "Market"; return ValuationMethodEnum_Market
                      `onFail` do isWord "Highest"; return ValuationMethodEnum_Highest
                      `onFail` do isWord "AverageMarket"; return ValuationMethodEnum_AverageMarket
                      `onFail` do isWord "AverageHighest"; return ValuationMethodEnum_AverageHighest
                      `onFail` do isWord "BlendedMarket"; return ValuationMethodEnum_BlendedMarket
                      `onFail` do isWord "BlendedHighest"; return ValuationMethodEnum_BlendedHighest
                      `onFail` do isWord "AverageBlendedMarket"; return ValuationMethodEnum_AverageBlendedMarket
                      `onFail` do isWord "AverageBlendedHighest"; return ValuationMethodEnum_AverageBlendedHighest
                      
    simpleTypeText ValuationMethodEnum_Market = "Market"
    simpleTypeText ValuationMethodEnum_Highest = "Highest"
    simpleTypeText ValuationMethodEnum_AverageMarket = "AverageMarket"
    simpleTypeText ValuationMethodEnum_AverageHighest = "AverageHighest"
    simpleTypeText ValuationMethodEnum_BlendedMarket = "BlendedMarket"
    simpleTypeText ValuationMethodEnum_BlendedHighest = "BlendedHighest"
    simpleTypeText ValuationMethodEnum_AverageBlendedMarket = "AverageBlendedMarket"
    simpleTypeText ValuationMethodEnum_AverageBlendedHighest = "AverageBlendedHighest"
 
-- | The specification of a weekly roll day.
data WeeklyRollConventionEnum
    = WeeklyRollConventionEnum_MON
      -- ^ Monday
    | WeeklyRollConventionEnum_TUE
      -- ^ Tuesday
    | WeeklyRollConventionEnum_WED
      -- ^ Wednesday
    | WeeklyRollConventionEnum_THU
      -- ^ Thursday
    | WeeklyRollConventionEnum_FRI
      -- ^ Friday
    | WeeklyRollConventionEnum_SAT
      -- ^ Saturday
    | WeeklyRollConventionEnum_SUN
      -- ^ Sunday
    | WeeklyRollConventionEnum_TBILL
      -- ^ 13-week and 26-week U.S. Treasury Bill Auction Dates. Each 
      --   Monday except for U.S. (New York) holidays when it will 
      --   occur on a Tuesday.
    deriving (Eq,Show,Enum)
instance SchemaType WeeklyRollConventionEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType WeeklyRollConventionEnum where
    acceptingParser =  do isWord "MON"; return WeeklyRollConventionEnum_MON
                      `onFail` do isWord "TUE"; return WeeklyRollConventionEnum_TUE
                      `onFail` do isWord "WED"; return WeeklyRollConventionEnum_WED
                      `onFail` do isWord "THU"; return WeeklyRollConventionEnum_THU
                      `onFail` do isWord "FRI"; return WeeklyRollConventionEnum_FRI
                      `onFail` do isWord "SAT"; return WeeklyRollConventionEnum_SAT
                      `onFail` do isWord "SUN"; return WeeklyRollConventionEnum_SUN
                      `onFail` do isWord "TBILL"; return WeeklyRollConventionEnum_TBILL
                      
    simpleTypeText WeeklyRollConventionEnum_MON = "MON"
    simpleTypeText WeeklyRollConventionEnum_TUE = "TUE"
    simpleTypeText WeeklyRollConventionEnum_WED = "WED"
    simpleTypeText WeeklyRollConventionEnum_THU = "THU"
    simpleTypeText WeeklyRollConventionEnum_FRI = "FRI"
    simpleTypeText WeeklyRollConventionEnum_SAT = "SAT"
    simpleTypeText WeeklyRollConventionEnum_SUN = "SUN"
    simpleTypeText WeeklyRollConventionEnum_TBILL = "TBILL"
 
-- | The type of telephone number used to reach a contact.
data TelephoneTypeEnum
    = TelephoneTypeEnum_Work
      -- ^ A number used primarily for work-related calls. Includes 
      --   home office numbers used primarily for work purposes.
    | TelephoneTypeEnum_Mobile
      -- ^ A number on a mobile telephone or pager that is often or 
      --   usually used for work-related calls. This type of number 
      --   can be used for urgent work related business when a work 
      --   number is not sufficient to contact the person or firm.
    | TelephoneTypeEnum_Fax
      -- ^ A number used primarily for work-related facsimile 
      --   transmissions.
    | TelephoneTypeEnum_Personal
      -- ^ A number used primarily for nonwork-related calls. 
      --   (Normally this type of number would be used only as an 
      --   emergency backup number, not as a regular course of 
      --   business).
    deriving (Eq,Show,Enum)
instance SchemaType TelephoneTypeEnum where
    parseSchemaType s = do
        e <- element [s]
        commit $ interior e $ parseSimpleType
    schemaTypeToXML s x = 
        toXMLElement s [] [toXMLText (simpleTypeText x)]
instance SimpleType TelephoneTypeEnum where
    acceptingParser =  do isWord "Work"; return TelephoneTypeEnum_Work
                      `onFail` do isWord "Mobile"; return TelephoneTypeEnum_Mobile
                      `onFail` do isWord "Fax"; return TelephoneTypeEnum_Fax
                      `onFail` do isWord "Personal"; return TelephoneTypeEnum_Personal
                      
    simpleTypeText TelephoneTypeEnum_Work = "Work"
    simpleTypeText TelephoneTypeEnum_Mobile = "Mobile"
    simpleTypeText TelephoneTypeEnum_Fax = "Fax"
    simpleTypeText TelephoneTypeEnum_Personal = "Personal"