FpMLv53-0.1: Data/FpML/V53/Enum.hs
{-# 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"
-- | >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.>
| 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"