module Data.FpML.V53.Eqd
( module Data.FpML.V53.Eqd
, module Data.FpML.V53.Shared.EQ
) 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
import Data.FpML.V53.Shared.EQ
data BrokerEquityOption = BrokerEquityOption
{ brokerEquityOption_ID :: Maybe Xsd.ID
, brokerEquityOption_primaryAssetClass :: Maybe AssetClass
, brokerEquityOption_secondaryAssetClass :: [AssetClass]
, brokerEquityOption_productType :: [ProductType]
, brokerEquityOption_productId :: [ProductId]
, brokerEquityOption_buyerPartyReference :: Maybe PartyReference
, brokerEquityOption_buyerAccountReference :: Maybe AccountReference
, brokerEquityOption_sellerPartyReference :: Maybe PartyReference
, brokerEquityOption_sellerAccountReference :: Maybe AccountReference
, brokerEquityOption_optionType :: Maybe EquityOptionTypeEnum
, brokerEquityOption_equityEffectiveDate :: Maybe Xsd.Date
, brokerEquityOption_underlyer :: Maybe Underlyer
, brokerEquityOption_notional :: Maybe NonNegativeMoney
, brokerEquityOption_equityExercise :: Maybe EquityExerciseValuationSettlement
, brokerEquityOption_feature :: Maybe OptionFeatures
, brokerEquityOption_fxFeature :: Maybe FxFeature
, brokerEquityOption_strategyFeature :: Maybe StrategyFeature
, brokerEquityOption_strike :: Maybe EquityStrike
, brokerEquityOption_spotPrice :: Maybe NonNegativeDecimal
, brokerEquityOption_numberOfOptions :: Maybe NonNegativeDecimal
, brokerEquityOption_equityPremium :: Maybe EquityPremium
, brokerEquityOption_deltaCrossed :: Maybe Xsd.Boolean
, brokerEquityOption_brokerageFee :: Maybe Money
, brokerEquityOption_brokerNotes :: Maybe Xsd.XsdString
}
deriving (Eq,Show)
instance SchemaType BrokerEquityOption where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (BrokerEquityOption a0)
`apply` optional (parseSchemaType "primaryAssetClass")
`apply` many (parseSchemaType "secondaryAssetClass")
`apply` many (parseSchemaType "productType")
`apply` many (parseSchemaType "productId")
`apply` optional (parseSchemaType "buyerPartyReference")
`apply` optional (parseSchemaType "buyerAccountReference")
`apply` optional (parseSchemaType "sellerPartyReference")
`apply` optional (parseSchemaType "sellerAccountReference")
`apply` optional (parseSchemaType "optionType")
`apply` optional (parseSchemaType "equityEffectiveDate")
`apply` optional (parseSchemaType "underlyer")
`apply` optional (parseSchemaType "notional")
`apply` optional (parseSchemaType "equityExercise")
`apply` optional (parseSchemaType "feature")
`apply` optional (parseSchemaType "fxFeature")
`apply` optional (parseSchemaType "strategyFeature")
`apply` optional (parseSchemaType "strike")
`apply` optional (parseSchemaType "spotPrice")
`apply` optional (parseSchemaType "numberOfOptions")
`apply` optional (parseSchemaType "equityPremium")
`apply` optional (parseSchemaType "deltaCrossed")
`apply` optional (parseSchemaType "brokerageFee")
`apply` optional (parseSchemaType "brokerNotes")
schemaTypeToXML s x@BrokerEquityOption{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ brokerEquityOption_ID x
]
[ maybe [] (schemaTypeToXML "primaryAssetClass") $ brokerEquityOption_primaryAssetClass x
, concatMap (schemaTypeToXML "secondaryAssetClass") $ brokerEquityOption_secondaryAssetClass x
, concatMap (schemaTypeToXML "productType") $ brokerEquityOption_productType x
, concatMap (schemaTypeToXML "productId") $ brokerEquityOption_productId x
, maybe [] (schemaTypeToXML "buyerPartyReference") $ brokerEquityOption_buyerPartyReference x
, maybe [] (schemaTypeToXML "buyerAccountReference") $ brokerEquityOption_buyerAccountReference x
, maybe [] (schemaTypeToXML "sellerPartyReference") $ brokerEquityOption_sellerPartyReference x
, maybe [] (schemaTypeToXML "sellerAccountReference") $ brokerEquityOption_sellerAccountReference x
, maybe [] (schemaTypeToXML "optionType") $ brokerEquityOption_optionType x
, maybe [] (schemaTypeToXML "equityEffectiveDate") $ brokerEquityOption_equityEffectiveDate x
, maybe [] (schemaTypeToXML "underlyer") $ brokerEquityOption_underlyer x
, maybe [] (schemaTypeToXML "notional") $ brokerEquityOption_notional x
, maybe [] (schemaTypeToXML "equityExercise") $ brokerEquityOption_equityExercise x
, maybe [] (schemaTypeToXML "feature") $ brokerEquityOption_feature x
, maybe [] (schemaTypeToXML "fxFeature") $ brokerEquityOption_fxFeature x
, maybe [] (schemaTypeToXML "strategyFeature") $ brokerEquityOption_strategyFeature x
, maybe [] (schemaTypeToXML "strike") $ brokerEquityOption_strike x
, maybe [] (schemaTypeToXML "spotPrice") $ brokerEquityOption_spotPrice x
, maybe [] (schemaTypeToXML "numberOfOptions") $ brokerEquityOption_numberOfOptions x
, maybe [] (schemaTypeToXML "equityPremium") $ brokerEquityOption_equityPremium x
, maybe [] (schemaTypeToXML "deltaCrossed") $ brokerEquityOption_deltaCrossed x
, maybe [] (schemaTypeToXML "brokerageFee") $ brokerEquityOption_brokerageFee x
, maybe [] (schemaTypeToXML "brokerNotes") $ brokerEquityOption_brokerNotes x
]
instance Extension BrokerEquityOption EquityDerivativeShortFormBase where
supertype v = EquityDerivativeShortFormBase_BrokerEquityOption v
instance Extension BrokerEquityOption EquityDerivativeBase where
supertype = (supertype :: EquityDerivativeShortFormBase -> EquityDerivativeBase)
. (supertype :: BrokerEquityOption -> EquityDerivativeShortFormBase)
instance Extension BrokerEquityOption Product where
supertype = (supertype :: EquityDerivativeBase -> Product)
. (supertype :: EquityDerivativeShortFormBase -> EquityDerivativeBase)
. (supertype :: BrokerEquityOption -> EquityDerivativeShortFormBase)
data EquityAmericanExercise = EquityAmericanExercise
{ equityAmericExerc_ID :: Maybe Xsd.ID
, equityAmericExerc_commencementDate :: Maybe AdjustableOrRelativeDate
, equityAmericExerc_expirationDate :: Maybe AdjustableOrRelativeDate
, equityAmericExerc_choice2 :: (Maybe (OneOf2 BusinessCenterTime DeterminationMethod))
, equityAmericExerc_latestExerciseTimeType :: Maybe TimeTypeEnum
, equityAmericExerc_choice4 :: (Maybe (OneOf2 ((Maybe (TimeTypeEnum)),(Maybe (BusinessCenterTime))) DeterminationMethod))
, equityAmericExerc_equityMultipleExercise :: Maybe EquityMultipleExercise
}
deriving (Eq,Show)
instance SchemaType EquityAmericanExercise where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (EquityAmericanExercise a0)
`apply` optional (parseSchemaType "commencementDate")
`apply` optional (parseSchemaType "expirationDate")
`apply` optional (oneOf' [ ("BusinessCenterTime", fmap OneOf2 (parseSchemaType "latestExerciseTime"))
, ("DeterminationMethod", fmap TwoOf2 (parseSchemaType "latestExerciseTimeDetermination"))
])
`apply` optional (parseSchemaType "latestExerciseTimeType")
`apply` optional (oneOf' [ ("Maybe TimeTypeEnum Maybe BusinessCenterTime", fmap OneOf2 (return (,) `apply` optional (parseSchemaType "equityExpirationTimeType")
`apply` optional (parseSchemaType "equityExpirationTime")))
, ("DeterminationMethod", fmap TwoOf2 (parseSchemaType "expirationTimeDetermination"))
])
`apply` optional (parseSchemaType "equityMultipleExercise")
schemaTypeToXML s x@EquityAmericanExercise{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ equityAmericExerc_ID x
]
[ maybe [] (schemaTypeToXML "commencementDate") $ equityAmericExerc_commencementDate x
, maybe [] (schemaTypeToXML "expirationDate") $ equityAmericExerc_expirationDate x
, maybe [] (foldOneOf2 (schemaTypeToXML "latestExerciseTime")
(schemaTypeToXML "latestExerciseTimeDetermination")
) $ equityAmericExerc_choice2 x
, maybe [] (schemaTypeToXML "latestExerciseTimeType") $ equityAmericExerc_latestExerciseTimeType x
, maybe [] (foldOneOf2 (\ (a,b) -> concat [ maybe [] (schemaTypeToXML "equityExpirationTimeType") a
, maybe [] (schemaTypeToXML "equityExpirationTime") b
])
(schemaTypeToXML "expirationTimeDetermination")
) $ equityAmericExerc_choice4 x
, maybe [] (schemaTypeToXML "equityMultipleExercise") $ equityAmericExerc_equityMultipleExercise x
]
instance Extension EquityAmericanExercise SharedAmericanExercise where
supertype (EquityAmericanExercise a0 e0 e1 e2 e3 e4 e5) =
SharedAmericanExercise a0 e0 e1 e2
instance Extension EquityAmericanExercise Exercise where
supertype = (supertype :: SharedAmericanExercise -> Exercise)
. (supertype :: EquityAmericanExercise -> SharedAmericanExercise)
data EquityBermudaExercise = EquityBermudaExercise
{ equityBermudaExerc_ID :: Maybe Xsd.ID
, equityBermudaExerc_commencementDate :: Maybe AdjustableOrRelativeDate
, equityBermudaExerc_expirationDate :: Maybe AdjustableOrRelativeDate
, equityBermudaExerc_choice2 :: (Maybe (OneOf2 BusinessCenterTime DeterminationMethod))
, equityBermudaExerc_bermudaExerciseDates :: Maybe DateList
, equityBermudaExerc_latestExerciseTimeType :: Maybe TimeTypeEnum
, equityBermudaExerc_choice5 :: (Maybe (OneOf2 ((Maybe (TimeTypeEnum)),(Maybe (BusinessCenterTime))) DeterminationMethod))
, equityBermudaExerc_equityMultipleExercise :: Maybe EquityMultipleExercise
}
deriving (Eq,Show)
instance SchemaType EquityBermudaExercise where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (EquityBermudaExercise a0)
`apply` optional (parseSchemaType "commencementDate")
`apply` optional (parseSchemaType "expirationDate")
`apply` optional (oneOf' [ ("BusinessCenterTime", fmap OneOf2 (parseSchemaType "latestExerciseTime"))
, ("DeterminationMethod", fmap TwoOf2 (parseSchemaType "latestExerciseTimeDetermination"))
])
`apply` optional (parseSchemaType "bermudaExerciseDates")
`apply` optional (parseSchemaType "latestExerciseTimeType")
`apply` optional (oneOf' [ ("Maybe TimeTypeEnum Maybe BusinessCenterTime", fmap OneOf2 (return (,) `apply` optional (parseSchemaType "equityExpirationTimeType")
`apply` optional (parseSchemaType "equityExpirationTime")))
, ("DeterminationMethod", fmap TwoOf2 (parseSchemaType "expirationTimeDetermination"))
])
`apply` optional (parseSchemaType "equityMultipleExercise")
schemaTypeToXML s x@EquityBermudaExercise{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ equityBermudaExerc_ID x
]
[ maybe [] (schemaTypeToXML "commencementDate") $ equityBermudaExerc_commencementDate x
, maybe [] (schemaTypeToXML "expirationDate") $ equityBermudaExerc_expirationDate x
, maybe [] (foldOneOf2 (schemaTypeToXML "latestExerciseTime")
(schemaTypeToXML "latestExerciseTimeDetermination")
) $ equityBermudaExerc_choice2 x
, maybe [] (schemaTypeToXML "bermudaExerciseDates") $ equityBermudaExerc_bermudaExerciseDates x
, maybe [] (schemaTypeToXML "latestExerciseTimeType") $ equityBermudaExerc_latestExerciseTimeType x
, maybe [] (foldOneOf2 (\ (a,b) -> concat [ maybe [] (schemaTypeToXML "equityExpirationTimeType") a
, maybe [] (schemaTypeToXML "equityExpirationTime") b
])
(schemaTypeToXML "expirationTimeDetermination")
) $ equityBermudaExerc_choice5 x
, maybe [] (schemaTypeToXML "equityMultipleExercise") $ equityBermudaExerc_equityMultipleExercise x
]
instance Extension EquityBermudaExercise SharedAmericanExercise where
supertype (EquityBermudaExercise a0 e0 e1 e2 e3 e4 e5 e6) =
SharedAmericanExercise a0 e0 e1 e2
instance Extension EquityBermudaExercise Exercise where
supertype = (supertype :: SharedAmericanExercise -> Exercise)
. (supertype :: EquityBermudaExercise -> SharedAmericanExercise)
data EquityDerivativeBase
= EquityDerivativeBase_EquityDerivativeShortFormBase EquityDerivativeShortFormBase
| EquityDerivativeBase_EquityDerivativeLongFormBase EquityDerivativeLongFormBase
deriving (Eq,Show)
instance SchemaType EquityDerivativeBase where
parseSchemaType s = do
(fmap EquityDerivativeBase_EquityDerivativeShortFormBase $ parseSchemaType s)
`onFail`
(fmap EquityDerivativeBase_EquityDerivativeLongFormBase $ parseSchemaType s)
`onFail` fail "Parse failed when expecting an extension type of EquityDerivativeBase,\n\
\ namely one of:\n\
\EquityDerivativeShortFormBase,EquityDerivativeLongFormBase"
schemaTypeToXML _s (EquityDerivativeBase_EquityDerivativeShortFormBase x) = schemaTypeToXML "equityDerivativeShortFormBase" x
schemaTypeToXML _s (EquityDerivativeBase_EquityDerivativeLongFormBase x) = schemaTypeToXML "equityDerivativeLongFormBase" x
instance Extension EquityDerivativeBase Product where
supertype v = Product_EquityDerivativeBase v
data EquityDerivativeLongFormBase
= EquityDerivativeLongFormBase_EquityOption EquityOption
| EquityDerivativeLongFormBase_EquityForward EquityForward
deriving (Eq,Show)
instance SchemaType EquityDerivativeLongFormBase where
parseSchemaType s = do
(fmap EquityDerivativeLongFormBase_EquityOption $ parseSchemaType s)
`onFail`
(fmap EquityDerivativeLongFormBase_EquityForward $ parseSchemaType s)
`onFail` fail "Parse failed when expecting an extension type of EquityDerivativeLongFormBase,\n\
\ namely one of:\n\
\EquityOption,EquityForward"
schemaTypeToXML _s (EquityDerivativeLongFormBase_EquityOption x) = schemaTypeToXML "equityOption" x
schemaTypeToXML _s (EquityDerivativeLongFormBase_EquityForward x) = schemaTypeToXML "equityForward" x
instance Extension EquityDerivativeLongFormBase EquityDerivativeBase where
supertype v = EquityDerivativeBase_EquityDerivativeLongFormBase v
data EquityDerivativeShortFormBase
= EquityDerivativeShortFormBase_EquityOptionTransactionSupplement EquityOptionTransactionSupplement
| EquityDerivativeShortFormBase_BrokerEquityOption BrokerEquityOption
deriving (Eq,Show)
instance SchemaType EquityDerivativeShortFormBase where
parseSchemaType s = do
(fmap EquityDerivativeShortFormBase_EquityOptionTransactionSupplement $ parseSchemaType s)
`onFail`
(fmap EquityDerivativeShortFormBase_BrokerEquityOption $ parseSchemaType s)
`onFail` fail "Parse failed when expecting an extension type of EquityDerivativeShortFormBase,\n\
\ namely one of:\n\
\EquityOptionTransactionSupplement,BrokerEquityOption"
schemaTypeToXML _s (EquityDerivativeShortFormBase_EquityOptionTransactionSupplement x) = schemaTypeToXML "equityOptionTransactionSupplement" x
schemaTypeToXML _s (EquityDerivativeShortFormBase_BrokerEquityOption x) = schemaTypeToXML "brokerEquityOption" x
instance Extension EquityDerivativeShortFormBase EquityDerivativeBase where
supertype v = EquityDerivativeBase_EquityDerivativeShortFormBase v
data EquityEuropeanExercise = EquityEuropeanExercise
{ equityEuropExerc_ID :: Maybe Xsd.ID
, equityEuropExerc_expirationDate :: Maybe AdjustableOrRelativeDate
, equityEuropExerc_choice1 :: (Maybe (OneOf2 ((Maybe (TimeTypeEnum)),(Maybe (BusinessCenterTime))) DeterminationMethod))
}
deriving (Eq,Show)
instance SchemaType EquityEuropeanExercise where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (EquityEuropeanExercise a0)
`apply` optional (parseSchemaType "expirationDate")
`apply` optional (oneOf' [ ("Maybe TimeTypeEnum Maybe BusinessCenterTime", fmap OneOf2 (return (,) `apply` optional (parseSchemaType "equityExpirationTimeType")
`apply` optional (parseSchemaType "equityExpirationTime")))
, ("DeterminationMethod", fmap TwoOf2 (parseSchemaType "expirationTimeDetermination"))
])
schemaTypeToXML s x@EquityEuropeanExercise{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ equityEuropExerc_ID x
]
[ maybe [] (schemaTypeToXML "expirationDate") $ equityEuropExerc_expirationDate x
, maybe [] (foldOneOf2 (\ (a,b) -> concat [ maybe [] (schemaTypeToXML "equityExpirationTimeType") a
, maybe [] (schemaTypeToXML "equityExpirationTime") b
])
(schemaTypeToXML "expirationTimeDetermination")
) $ equityEuropExerc_choice1 x
]
instance Extension EquityEuropeanExercise Exercise where
supertype v = Exercise_EquityEuropeanExercise v
data EquityExerciseValuationSettlement = EquityExerciseValuationSettlement
{ equityExercValSettl_choice0 :: (Maybe (OneOf3 EquityEuropeanExercise EquityAmericanExercise EquityBermudaExercise))
, equityExercValSettl_choice1 :: (Maybe (OneOf2 ((Maybe (Xsd.Boolean)),(Maybe (MakeWholeProvisions))) PrePayment))
, equityExercValSettl_equityValuation :: Maybe EquityValuation
, equityExercValSettl_settlementDate :: Maybe AdjustableOrRelativeDate
, equityExercValSettl_settlementCurrency :: Maybe Currency
, equityExercValSettl_settlementPriceSource :: Maybe SettlementPriceSource
, equityExercValSettl_settlementType :: Maybe SettlementTypeEnum
, equityExercValSettl_settlementMethodElectionDate :: Maybe AdjustableOrRelativeDate
, equityExercValSettl_settlementMethodElectingPartyReference :: Maybe PartyReference
, equityExercValSettl_settlementPriceDefaultElection :: Maybe SettlementPriceDefaultElection
}
deriving (Eq,Show)
instance SchemaType EquityExerciseValuationSettlement where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return EquityExerciseValuationSettlement
`apply` optional (oneOf' [ ("EquityEuropeanExercise", fmap OneOf3 (parseSchemaType "equityEuropeanExercise"))
, ("EquityAmericanExercise", fmap TwoOf3 (parseSchemaType "equityAmericanExercise"))
, ("EquityBermudaExercise", fmap ThreeOf3 (parseSchemaType "equityBermudaExercise"))
])
`apply` optional (oneOf' [ ("Maybe Xsd.Boolean Maybe MakeWholeProvisions", fmap OneOf2 (return (,) `apply` optional (parseSchemaType "automaticExercise")
`apply` optional (parseSchemaType "makeWholeProvisions")))
, ("PrePayment", fmap TwoOf2 (parseSchemaType "prePayment"))
])
`apply` optional (parseSchemaType "equityValuation")
`apply` optional (parseSchemaType "settlementDate")
`apply` optional (parseSchemaType "settlementCurrency")
`apply` optional (parseSchemaType "settlementPriceSource")
`apply` optional (parseSchemaType "settlementType")
`apply` optional (parseSchemaType "settlementMethodElectionDate")
`apply` optional (parseSchemaType "settlementMethodElectingPartyReference")
`apply` optional (parseSchemaType "settlementPriceDefaultElection")
schemaTypeToXML s x@EquityExerciseValuationSettlement{} =
toXMLElement s []
[ maybe [] (foldOneOf3 (schemaTypeToXML "equityEuropeanExercise")
(schemaTypeToXML "equityAmericanExercise")
(schemaTypeToXML "equityBermudaExercise")
) $ equityExercValSettl_choice0 x
, maybe [] (foldOneOf2 (\ (a,b) -> concat [ maybe [] (schemaTypeToXML "automaticExercise") a
, maybe [] (schemaTypeToXML "makeWholeProvisions") b
])
(schemaTypeToXML "prePayment")
) $ equityExercValSettl_choice1 x
, maybe [] (schemaTypeToXML "equityValuation") $ equityExercValSettl_equityValuation x
, maybe [] (schemaTypeToXML "settlementDate") $ equityExercValSettl_settlementDate x
, maybe [] (schemaTypeToXML "settlementCurrency") $ equityExercValSettl_settlementCurrency x
, maybe [] (schemaTypeToXML "settlementPriceSource") $ equityExercValSettl_settlementPriceSource x
, maybe [] (schemaTypeToXML "settlementType") $ equityExercValSettl_settlementType x
, maybe [] (schemaTypeToXML "settlementMethodElectionDate") $ equityExercValSettl_settlementMethodElectionDate x
, maybe [] (schemaTypeToXML "settlementMethodElectingPartyReference") $ equityExercValSettl_settlementMethodElectingPartyReference x
, maybe [] (schemaTypeToXML "settlementPriceDefaultElection") $ equityExercValSettl_settlementPriceDefaultElection x
]
data EquityForward = EquityForward
{ equityForward_ID :: Maybe Xsd.ID
, equityForward_primaryAssetClass :: Maybe AssetClass
, equityForward_secondaryAssetClass :: [AssetClass]
, equityForward_productType :: [ProductType]
, equityForward_productId :: [ProductId]
, equityForward_buyerPartyReference :: Maybe PartyReference
, equityForward_buyerAccountReference :: Maybe AccountReference
, equityForward_sellerPartyReference :: Maybe PartyReference
, equityForward_sellerAccountReference :: Maybe AccountReference
, equityForward_optionType :: Maybe EquityOptionTypeEnum
, equityForward_equityEffectiveDate :: Maybe Xsd.Date
, equityForward_underlyer :: Maybe Underlyer
, equityForward_notional :: Maybe NonNegativeMoney
, equityForward_equityExercise :: Maybe EquityExerciseValuationSettlement
, equityForward_feature :: Maybe OptionFeatures
, equityForward_fxFeature :: Maybe FxFeature
, equityForward_strategyFeature :: Maybe StrategyFeature
, equityForward_dividendConditions :: Maybe DividendConditions
, equityForward_methodOfAdjustment :: Maybe MethodOfAdjustmentEnum
, equityForward_extraordinaryEvents :: Maybe ExtraordinaryEvents
, equityForward_forwardPrice :: NonNegativeMoney
}
deriving (Eq,Show)
instance SchemaType EquityForward where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (EquityForward a0)
`apply` optional (parseSchemaType "primaryAssetClass")
`apply` many (parseSchemaType "secondaryAssetClass")
`apply` many (parseSchemaType "productType")
`apply` many (parseSchemaType "productId")
`apply` optional (parseSchemaType "buyerPartyReference")
`apply` optional (parseSchemaType "buyerAccountReference")
`apply` optional (parseSchemaType "sellerPartyReference")
`apply` optional (parseSchemaType "sellerAccountReference")
`apply` optional (parseSchemaType "optionType")
`apply` optional (parseSchemaType "equityEffectiveDate")
`apply` optional (parseSchemaType "underlyer")
`apply` optional (parseSchemaType "notional")
`apply` optional (parseSchemaType "equityExercise")
`apply` optional (parseSchemaType "feature")
`apply` optional (parseSchemaType "fxFeature")
`apply` optional (parseSchemaType "strategyFeature")
`apply` optional (parseSchemaType "dividendConditions")
`apply` optional (parseSchemaType "methodOfAdjustment")
`apply` optional (parseSchemaType "extraordinaryEvents")
`apply` parseSchemaType "forwardPrice"
schemaTypeToXML s x@EquityForward{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ equityForward_ID x
]
[ maybe [] (schemaTypeToXML "primaryAssetClass") $ equityForward_primaryAssetClass x
, concatMap (schemaTypeToXML "secondaryAssetClass") $ equityForward_secondaryAssetClass x
, concatMap (schemaTypeToXML "productType") $ equityForward_productType x
, concatMap (schemaTypeToXML "productId") $ equityForward_productId x
, maybe [] (schemaTypeToXML "buyerPartyReference") $ equityForward_buyerPartyReference x
, maybe [] (schemaTypeToXML "buyerAccountReference") $ equityForward_buyerAccountReference x
, maybe [] (schemaTypeToXML "sellerPartyReference") $ equityForward_sellerPartyReference x
, maybe [] (schemaTypeToXML "sellerAccountReference") $ equityForward_sellerAccountReference x
, maybe [] (schemaTypeToXML "optionType") $ equityForward_optionType x
, maybe [] (schemaTypeToXML "equityEffectiveDate") $ equityForward_equityEffectiveDate x
, maybe [] (schemaTypeToXML "underlyer") $ equityForward_underlyer x
, maybe [] (schemaTypeToXML "notional") $ equityForward_notional x
, maybe [] (schemaTypeToXML "equityExercise") $ equityForward_equityExercise x
, maybe [] (schemaTypeToXML "feature") $ equityForward_feature x
, maybe [] (schemaTypeToXML "fxFeature") $ equityForward_fxFeature x
, maybe [] (schemaTypeToXML "strategyFeature") $ equityForward_strategyFeature x
, maybe [] (schemaTypeToXML "dividendConditions") $ equityForward_dividendConditions x
, maybe [] (schemaTypeToXML "methodOfAdjustment") $ equityForward_methodOfAdjustment x
, maybe [] (schemaTypeToXML "extraordinaryEvents") $ equityForward_extraordinaryEvents x
, schemaTypeToXML "forwardPrice" $ equityForward_forwardPrice x
]
instance Extension EquityForward EquityDerivativeLongFormBase where
supertype v = EquityDerivativeLongFormBase_EquityForward v
instance Extension EquityForward EquityDerivativeBase where
supertype = (supertype :: EquityDerivativeLongFormBase -> EquityDerivativeBase)
. (supertype :: EquityForward -> EquityDerivativeLongFormBase)
instance Extension EquityForward Product where
supertype = (supertype :: EquityDerivativeBase -> Product)
. (supertype :: EquityDerivativeLongFormBase -> EquityDerivativeBase)
. (supertype :: EquityForward -> EquityDerivativeLongFormBase)
data EquityMultipleExercise = EquityMultipleExercise
{ equityMultiExerc_integralMultipleExercise :: Maybe PositiveDecimal
, equityMultiExerc_minimumNumberOfOptions :: Maybe NonNegativeDecimal
, equityMultiExerc_maximumNumberOfOptions :: Maybe NonNegativeDecimal
}
deriving (Eq,Show)
instance SchemaType EquityMultipleExercise where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return EquityMultipleExercise
`apply` optional (parseSchemaType "integralMultipleExercise")
`apply` optional (parseSchemaType "minimumNumberOfOptions")
`apply` optional (parseSchemaType "maximumNumberOfOptions")
schemaTypeToXML s x@EquityMultipleExercise{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "integralMultipleExercise") $ equityMultiExerc_integralMultipleExercise x
, maybe [] (schemaTypeToXML "minimumNumberOfOptions") $ equityMultiExerc_minimumNumberOfOptions x
, maybe [] (schemaTypeToXML "maximumNumberOfOptions") $ equityMultiExerc_maximumNumberOfOptions x
]
data EquityOption = EquityOption
{ equityOption_ID :: Maybe Xsd.ID
, equityOption_primaryAssetClass :: Maybe AssetClass
, equityOption_secondaryAssetClass :: [AssetClass]
, equityOption_productType :: [ProductType]
, equityOption_productId :: [ProductId]
, equityOption_buyerPartyReference :: Maybe PartyReference
, equityOption_buyerAccountReference :: Maybe AccountReference
, equityOption_sellerPartyReference :: Maybe PartyReference
, equityOption_sellerAccountReference :: Maybe AccountReference
, equityOption_optionType :: Maybe EquityOptionTypeEnum
, equityOption_equityEffectiveDate :: Maybe Xsd.Date
, equityOption_underlyer :: Maybe Underlyer
, equityOption_notional :: Maybe NonNegativeMoney
, equityOption_equityExercise :: Maybe EquityExerciseValuationSettlement
, equityOption_feature :: Maybe OptionFeatures
, equityOption_fxFeature :: Maybe FxFeature
, equityOption_strategyFeature :: Maybe StrategyFeature
, equityOption_dividendConditions :: Maybe DividendConditions
, equityOption_methodOfAdjustment :: Maybe MethodOfAdjustmentEnum
, equityOption_extraordinaryEvents :: Maybe ExtraordinaryEvents
, equityOption_strike :: Maybe EquityStrike
, equityOption_spotPrice :: Maybe NonNegativeDecimal
, equityOption_numberOfOptions :: Maybe NonNegativeDecimal
, equityOption_optionEntitlement :: Maybe PositiveDecimal
, equityOption_equityPremium :: Maybe EquityPremium
}
deriving (Eq,Show)
instance SchemaType EquityOption where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (EquityOption a0)
`apply` optional (parseSchemaType "primaryAssetClass")
`apply` many (parseSchemaType "secondaryAssetClass")
`apply` many (parseSchemaType "productType")
`apply` many (parseSchemaType "productId")
`apply` optional (parseSchemaType "buyerPartyReference")
`apply` optional (parseSchemaType "buyerAccountReference")
`apply` optional (parseSchemaType "sellerPartyReference")
`apply` optional (parseSchemaType "sellerAccountReference")
`apply` optional (parseSchemaType "optionType")
`apply` optional (parseSchemaType "equityEffectiveDate")
`apply` optional (parseSchemaType "underlyer")
`apply` optional (parseSchemaType "notional")
`apply` optional (parseSchemaType "equityExercise")
`apply` optional (parseSchemaType "feature")
`apply` optional (parseSchemaType "fxFeature")
`apply` optional (parseSchemaType "strategyFeature")
`apply` optional (parseSchemaType "dividendConditions")
`apply` optional (parseSchemaType "methodOfAdjustment")
`apply` optional (parseSchemaType "extraordinaryEvents")
`apply` optional (parseSchemaType "strike")
`apply` optional (parseSchemaType "spotPrice")
`apply` optional (parseSchemaType "numberOfOptions")
`apply` optional (parseSchemaType "optionEntitlement")
`apply` optional (parseSchemaType "equityPremium")
schemaTypeToXML s x@EquityOption{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ equityOption_ID x
]
[ maybe [] (schemaTypeToXML "primaryAssetClass") $ equityOption_primaryAssetClass x
, concatMap (schemaTypeToXML "secondaryAssetClass") $ equityOption_secondaryAssetClass x
, concatMap (schemaTypeToXML "productType") $ equityOption_productType x
, concatMap (schemaTypeToXML "productId") $ equityOption_productId x
, maybe [] (schemaTypeToXML "buyerPartyReference") $ equityOption_buyerPartyReference x
, maybe [] (schemaTypeToXML "buyerAccountReference") $ equityOption_buyerAccountReference x
, maybe [] (schemaTypeToXML "sellerPartyReference") $ equityOption_sellerPartyReference x
, maybe [] (schemaTypeToXML "sellerAccountReference") $ equityOption_sellerAccountReference x
, maybe [] (schemaTypeToXML "optionType") $ equityOption_optionType x
, maybe [] (schemaTypeToXML "equityEffectiveDate") $ equityOption_equityEffectiveDate x
, maybe [] (schemaTypeToXML "underlyer") $ equityOption_underlyer x
, maybe [] (schemaTypeToXML "notional") $ equityOption_notional x
, maybe [] (schemaTypeToXML "equityExercise") $ equityOption_equityExercise x
, maybe [] (schemaTypeToXML "feature") $ equityOption_feature x
, maybe [] (schemaTypeToXML "fxFeature") $ equityOption_fxFeature x
, maybe [] (schemaTypeToXML "strategyFeature") $ equityOption_strategyFeature x
, maybe [] (schemaTypeToXML "dividendConditions") $ equityOption_dividendConditions x
, maybe [] (schemaTypeToXML "methodOfAdjustment") $ equityOption_methodOfAdjustment x
, maybe [] (schemaTypeToXML "extraordinaryEvents") $ equityOption_extraordinaryEvents x
, maybe [] (schemaTypeToXML "strike") $ equityOption_strike x
, maybe [] (schemaTypeToXML "spotPrice") $ equityOption_spotPrice x
, maybe [] (schemaTypeToXML "numberOfOptions") $ equityOption_numberOfOptions x
, maybe [] (schemaTypeToXML "optionEntitlement") $ equityOption_optionEntitlement x
, maybe [] (schemaTypeToXML "equityPremium") $ equityOption_equityPremium x
]
instance Extension EquityOption EquityDerivativeLongFormBase where
supertype v = EquityDerivativeLongFormBase_EquityOption v
instance Extension EquityOption EquityDerivativeBase where
supertype = (supertype :: EquityDerivativeLongFormBase -> EquityDerivativeBase)
. (supertype :: EquityOption -> EquityDerivativeLongFormBase)
instance Extension EquityOption Product where
supertype = (supertype :: EquityDerivativeBase -> Product)
. (supertype :: EquityDerivativeLongFormBase -> EquityDerivativeBase)
. (supertype :: EquityOption -> EquityDerivativeLongFormBase)
data EquityOptionTermination = EquityOptionTermination
{ equityOptionTermin_settlementAmountPaymentDate :: Maybe AdjustableDate
, equityOptionTermin_settlementAmount :: Maybe NonNegativeMoney
}
deriving (Eq,Show)
instance SchemaType EquityOptionTermination where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return EquityOptionTermination
`apply` optional (parseSchemaType "settlementAmountPaymentDate")
`apply` optional (parseSchemaType "settlementAmount")
schemaTypeToXML s x@EquityOptionTermination{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "settlementAmountPaymentDate") $ equityOptionTermin_settlementAmountPaymentDate x
, maybe [] (schemaTypeToXML "settlementAmount") $ equityOptionTermin_settlementAmount x
]
data EquityOptionTransactionSupplement = EquityOptionTransactionSupplement
{ equityOptionTransSuppl_ID :: Maybe Xsd.ID
, equityOptionTransSuppl_primaryAssetClass :: Maybe AssetClass
, equityOptionTransSuppl_secondaryAssetClass :: [AssetClass]
, equityOptionTransSuppl_productType :: [ProductType]
, equityOptionTransSuppl_productId :: [ProductId]
, equityOptionTransSuppl_buyerPartyReference :: Maybe PartyReference
, equityOptionTransSuppl_buyerAccountReference :: Maybe AccountReference
, equityOptionTransSuppl_sellerPartyReference :: Maybe PartyReference
, equityOptionTransSuppl_sellerAccountReference :: Maybe AccountReference
, equityOptionTransSuppl_optionType :: Maybe EquityOptionTypeEnum
, equityOptionTransSuppl_equityEffectiveDate :: Maybe Xsd.Date
, equityOptionTransSuppl_underlyer :: Maybe Underlyer
, equityOptionTransSuppl_notional :: Maybe NonNegativeMoney
, equityOptionTransSuppl_equityExercise :: Maybe EquityExerciseValuationSettlement
, equityOptionTransSuppl_feature :: Maybe OptionFeatures
, equityOptionTransSuppl_fxFeature :: Maybe FxFeature
, equityOptionTransSuppl_strategyFeature :: Maybe StrategyFeature
, equityOptionTransSuppl_strike :: Maybe EquityStrike
, equityOptionTransSuppl_spotPrice :: Maybe NonNegativeDecimal
, equityOptionTransSuppl_numberOfOptions :: Maybe NonNegativeDecimal
, equityOptionTransSuppl_equityPremium :: Maybe EquityPremium
, equityOptionTransSuppl_exchangeLookAlike :: Maybe Xsd.Boolean
, equityOptionTransSuppl_exchangeTradedContractNearest :: Maybe Xsd.Boolean
, equityOptionTransSuppl_choice22 :: (Maybe (OneOf2 Xsd.Boolean Xsd.Boolean))
, equityOptionTransSuppl_methodOfAdjustment :: Maybe MethodOfAdjustmentEnum
, equityOptionTransSuppl_localJurisdiction :: Maybe CountryCode
, equityOptionTransSuppl_choice25 :: (Maybe (OneOf2 PositiveDecimal PositiveDecimal))
, equityOptionTransSuppl_extraordinaryEvents :: Maybe ExtraordinaryEvents
}
deriving (Eq,Show)
instance SchemaType EquityOptionTransactionSupplement where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (EquityOptionTransactionSupplement a0)
`apply` optional (parseSchemaType "primaryAssetClass")
`apply` many (parseSchemaType "secondaryAssetClass")
`apply` many (parseSchemaType "productType")
`apply` many (parseSchemaType "productId")
`apply` optional (parseSchemaType "buyerPartyReference")
`apply` optional (parseSchemaType "buyerAccountReference")
`apply` optional (parseSchemaType "sellerPartyReference")
`apply` optional (parseSchemaType "sellerAccountReference")
`apply` optional (parseSchemaType "optionType")
`apply` optional (parseSchemaType "equityEffectiveDate")
`apply` optional (parseSchemaType "underlyer")
`apply` optional (parseSchemaType "notional")
`apply` optional (parseSchemaType "equityExercise")
`apply` optional (parseSchemaType "feature")
`apply` optional (parseSchemaType "fxFeature")
`apply` optional (parseSchemaType "strategyFeature")
`apply` optional (parseSchemaType "strike")
`apply` optional (parseSchemaType "spotPrice")
`apply` optional (parseSchemaType "numberOfOptions")
`apply` optional (parseSchemaType "equityPremium")
`apply` optional (parseSchemaType "exchangeLookAlike")
`apply` optional (parseSchemaType "exchangeTradedContractNearest")
`apply` optional (oneOf' [ ("Xsd.Boolean", fmap OneOf2 (parseSchemaType "multipleExchangeIndexAnnexFallback"))
, ("Xsd.Boolean", fmap TwoOf2 (parseSchemaType "componentSecurityIndexAnnexFallback"))
])
`apply` optional (parseSchemaType "methodOfAdjustment")
`apply` optional (parseSchemaType "localJurisdiction")
`apply` optional (oneOf' [ ("PositiveDecimal", fmap OneOf2 (parseSchemaType "optionEntitlement"))
, ("PositiveDecimal", fmap TwoOf2 (parseSchemaType "multiplier"))
])
`apply` optional (parseSchemaType "extraordinaryEvents")
schemaTypeToXML s x@EquityOptionTransactionSupplement{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ equityOptionTransSuppl_ID x
]
[ maybe [] (schemaTypeToXML "primaryAssetClass") $ equityOptionTransSuppl_primaryAssetClass x
, concatMap (schemaTypeToXML "secondaryAssetClass") $ equityOptionTransSuppl_secondaryAssetClass x
, concatMap (schemaTypeToXML "productType") $ equityOptionTransSuppl_productType x
, concatMap (schemaTypeToXML "productId") $ equityOptionTransSuppl_productId x
, maybe [] (schemaTypeToXML "buyerPartyReference") $ equityOptionTransSuppl_buyerPartyReference x
, maybe [] (schemaTypeToXML "buyerAccountReference") $ equityOptionTransSuppl_buyerAccountReference x
, maybe [] (schemaTypeToXML "sellerPartyReference") $ equityOptionTransSuppl_sellerPartyReference x
, maybe [] (schemaTypeToXML "sellerAccountReference") $ equityOptionTransSuppl_sellerAccountReference x
, maybe [] (schemaTypeToXML "optionType") $ equityOptionTransSuppl_optionType x
, maybe [] (schemaTypeToXML "equityEffectiveDate") $ equityOptionTransSuppl_equityEffectiveDate x
, maybe [] (schemaTypeToXML "underlyer") $ equityOptionTransSuppl_underlyer x
, maybe [] (schemaTypeToXML "notional") $ equityOptionTransSuppl_notional x
, maybe [] (schemaTypeToXML "equityExercise") $ equityOptionTransSuppl_equityExercise x
, maybe [] (schemaTypeToXML "feature") $ equityOptionTransSuppl_feature x
, maybe [] (schemaTypeToXML "fxFeature") $ equityOptionTransSuppl_fxFeature x
, maybe [] (schemaTypeToXML "strategyFeature") $ equityOptionTransSuppl_strategyFeature x
, maybe [] (schemaTypeToXML "strike") $ equityOptionTransSuppl_strike x
, maybe [] (schemaTypeToXML "spotPrice") $ equityOptionTransSuppl_spotPrice x
, maybe [] (schemaTypeToXML "numberOfOptions") $ equityOptionTransSuppl_numberOfOptions x
, maybe [] (schemaTypeToXML "equityPremium") $ equityOptionTransSuppl_equityPremium x
, maybe [] (schemaTypeToXML "exchangeLookAlike") $ equityOptionTransSuppl_exchangeLookAlike x
, maybe [] (schemaTypeToXML "exchangeTradedContractNearest") $ equityOptionTransSuppl_exchangeTradedContractNearest x
, maybe [] (foldOneOf2 (schemaTypeToXML "multipleExchangeIndexAnnexFallback")
(schemaTypeToXML "componentSecurityIndexAnnexFallback")
) $ equityOptionTransSuppl_choice22 x
, maybe [] (schemaTypeToXML "methodOfAdjustment") $ equityOptionTransSuppl_methodOfAdjustment x
, maybe [] (schemaTypeToXML "localJurisdiction") $ equityOptionTransSuppl_localJurisdiction x
, maybe [] (foldOneOf2 (schemaTypeToXML "optionEntitlement")
(schemaTypeToXML "multiplier")
) $ equityOptionTransSuppl_choice25 x
, maybe [] (schemaTypeToXML "extraordinaryEvents") $ equityOptionTransSuppl_extraordinaryEvents x
]
instance Extension EquityOptionTransactionSupplement EquityDerivativeShortFormBase where
supertype v = EquityDerivativeShortFormBase_EquityOptionTransactionSupplement v
instance Extension EquityOptionTransactionSupplement EquityDerivativeBase where
supertype = (supertype :: EquityDerivativeShortFormBase -> EquityDerivativeBase)
. (supertype :: EquityOptionTransactionSupplement -> EquityDerivativeShortFormBase)
instance Extension EquityOptionTransactionSupplement Product where
supertype = (supertype :: EquityDerivativeBase -> Product)
. (supertype :: EquityDerivativeShortFormBase -> EquityDerivativeBase)
. (supertype :: EquityOptionTransactionSupplement -> EquityDerivativeShortFormBase)
data PrePayment = PrePayment
{ prePayment_ID :: Maybe Xsd.ID
, prePayment_payerPartyReference :: Maybe PartyReference
, prePayment_payerAccountReference :: Maybe AccountReference
, prePayment_receiverPartyReference :: Maybe PartyReference
, prePayment_receiverAccountReference :: Maybe AccountReference
, prePayment :: Maybe Xsd.Boolean
, prePayment_amount :: Maybe NonNegativeMoney
, prePayment_date :: Maybe AdjustableDate
}
deriving (Eq,Show)
instance SchemaType PrePayment where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (PrePayment a0)
`apply` optional (parseSchemaType "payerPartyReference")
`apply` optional (parseSchemaType "payerAccountReference")
`apply` optional (parseSchemaType "receiverPartyReference")
`apply` optional (parseSchemaType "receiverAccountReference")
`apply` optional (parseSchemaType "prePayment")
`apply` optional (parseSchemaType "prePaymentAmount")
`apply` optional (parseSchemaType "prePaymentDate")
schemaTypeToXML s x@PrePayment{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ prePayment_ID x
]
[ maybe [] (schemaTypeToXML "payerPartyReference") $ prePayment_payerPartyReference x
, maybe [] (schemaTypeToXML "payerAccountReference") $ prePayment_payerAccountReference x
, maybe [] (schemaTypeToXML "receiverPartyReference") $ prePayment_receiverPartyReference x
, maybe [] (schemaTypeToXML "receiverAccountReference") $ prePayment_receiverAccountReference x
, maybe [] (schemaTypeToXML "prePayment") $ prePayment x
, maybe [] (schemaTypeToXML "prePaymentAmount") $ prePayment_amount x
, maybe [] (schemaTypeToXML "prePaymentDate") $ prePayment_date x
]
instance Extension PrePayment PaymentBase where
supertype v = PaymentBase_PrePayment v
elementBrokerEquityOption :: XMLParser BrokerEquityOption
elementBrokerEquityOption = parseSchemaType "brokerEquityOption"
elementToXMLBrokerEquityOption :: BrokerEquityOption -> [Content ()]
elementToXMLBrokerEquityOption = schemaTypeToXML "brokerEquityOption"
elementEquityForward :: XMLParser EquityForward
elementEquityForward = parseSchemaType "equityForward"
elementToXMLEquityForward :: EquityForward -> [Content ()]
elementToXMLEquityForward = schemaTypeToXML "equityForward"
elementEquityOption :: XMLParser EquityOption
elementEquityOption = parseSchemaType "equityOption"
elementToXMLEquityOption :: EquityOption -> [Content ()]
elementToXMLEquityOption = schemaTypeToXML "equityOption"
elementEquityOptionTransactionSupplement :: XMLParser EquityOptionTransactionSupplement
elementEquityOptionTransactionSupplement = parseSchemaType "equityOptionTransactionSupplement"
elementToXMLEquityOptionTransactionSupplement :: EquityOptionTransactionSupplement -> [Content ()]
elementToXMLEquityOptionTransactionSupplement = schemaTypeToXML "equityOptionTransactionSupplement"