module Data.FpML.V53.Valuation
( module Data.FpML.V53.Valuation
, module Data.FpML.V53.Enum
, module Data.FpML.V53.Riskdef
, module Data.FpML.V53.Msg
, module Data.FpML.V53.Events.Business
) 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.Enum
import Data.FpML.V53.Riskdef
import Data.FpML.V53.Msg
import Data.FpML.V53.Events.Business
data AssetValuation = AssetValuation
{ assetVal_ID :: Maybe Xsd.ID
, assetVal_definitionRef :: Maybe Xsd.IDREF
, assetVal_objectReference :: Maybe AnyAssetReference
, assetVal_valuationScenarioReference :: Maybe ValuationScenarioReference
, assetVal_quote :: [Quotation]
, assetVal_fxRate :: [FxRate]
}
deriving (Eq,Show)
instance SchemaType AssetValuation where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
a1 <- optional $ getAttribute "definitionRef" e pos
commit $ interior e $ return (AssetValuation a0 a1)
`apply` optional (parseSchemaType "objectReference")
`apply` optional (parseSchemaType "valuationScenarioReference")
`apply` many (parseSchemaType "quote")
`apply` many (parseSchemaType "fxRate")
schemaTypeToXML s x@AssetValuation{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ assetVal_ID x
, maybe [] (toXMLAttribute "definitionRef") $ assetVal_definitionRef x
]
[ maybe [] (schemaTypeToXML "objectReference") $ assetVal_objectReference x
, maybe [] (schemaTypeToXML "valuationScenarioReference") $ assetVal_valuationScenarioReference x
, concatMap (schemaTypeToXML "quote") $ assetVal_quote x
, concatMap (schemaTypeToXML "fxRate") $ assetVal_fxRate x
]
instance Extension AssetValuation Valuation where
supertype (AssetValuation a0 a1 e0 e1 e2 e3) =
Valuation a0 a1 e0 e1
data DerivedValuationScenario = DerivedValuationScenario
{ derivedValScenar_ID :: Maybe Xsd.ID
, derivedValScenar_name :: Maybe Xsd.XsdString
, derivedValScenar_baseValuationScenario :: Maybe ValuationScenarioReference
, derivedValScenar_valuationDate :: Maybe IdentifiedDate
, derivedValScenar_marketReference :: Maybe MarketReference
, derivedValScenar_shift :: [PricingParameterShift]
}
deriving (Eq,Show)
instance SchemaType DerivedValuationScenario where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (DerivedValuationScenario a0)
`apply` optional (parseSchemaType "name")
`apply` optional (parseSchemaType "baseValuationScenario")
`apply` optional (parseSchemaType "valuationDate")
`apply` optional (parseSchemaType "marketReference")
`apply` many (parseSchemaType "shift")
schemaTypeToXML s x@DerivedValuationScenario{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ derivedValScenar_ID x
]
[ maybe [] (schemaTypeToXML "name") $ derivedValScenar_name x
, maybe [] (schemaTypeToXML "baseValuationScenario") $ derivedValScenar_baseValuationScenario x
, maybe [] (schemaTypeToXML "valuationDate") $ derivedValScenar_valuationDate x
, maybe [] (schemaTypeToXML "marketReference") $ derivedValScenar_marketReference x
, concatMap (schemaTypeToXML "shift") $ derivedValScenar_shift x
]
data Quotation = Quotation
{ quotation_value :: Maybe Xsd.Decimal
, quotation_measureType :: Maybe AssetMeasureType
, quotation_quoteUnits :: Maybe PriceQuoteUnits
, quotation_side :: Maybe QuotationSideEnum
, quotation_currency :: Maybe Currency
, quotation_currencyType :: Maybe ReportingCurrencyType
, quotation_timing :: Maybe QuoteTiming
, quotation_choice7 :: (Maybe (OneOf2 BusinessCenter ExchangeId))
, quotation_informationSource :: [InformationSource]
, quotation_pricingModel :: Maybe PricingModel
, quotation_time :: Maybe Xsd.DateTime
, quotation_valuationDate :: Maybe Xsd.Date
, quotation_expiryTime :: Maybe Xsd.DateTime
, quotation_cashflowType :: Maybe CashflowType
, quotation_sensitivitySet :: [SensitivitySet]
}
deriving (Eq,Show)
instance SchemaType Quotation where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return Quotation
`apply` optional (parseSchemaType "value")
`apply` optional (parseSchemaType "measureType")
`apply` optional (parseSchemaType "quoteUnits")
`apply` optional (parseSchemaType "side")
`apply` optional (parseSchemaType "currency")
`apply` optional (parseSchemaType "currencyType")
`apply` optional (parseSchemaType "timing")
`apply` optional (oneOf' [ ("BusinessCenter", fmap OneOf2 (parseSchemaType "businessCenter"))
, ("ExchangeId", fmap TwoOf2 (parseSchemaType "exchangeId"))
])
`apply` many (parseSchemaType "informationSource")
`apply` optional (parseSchemaType "pricingModel")
`apply` optional (parseSchemaType "time")
`apply` optional (parseSchemaType "valuationDate")
`apply` optional (parseSchemaType "expiryTime")
`apply` optional (parseSchemaType "cashflowType")
`apply` many (parseSchemaType "sensitivitySet")
schemaTypeToXML s x@Quotation{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "value") $ quotation_value x
, maybe [] (schemaTypeToXML "measureType") $ quotation_measureType x
, maybe [] (schemaTypeToXML "quoteUnits") $ quotation_quoteUnits x
, maybe [] (schemaTypeToXML "side") $ quotation_side x
, maybe [] (schemaTypeToXML "currency") $ quotation_currency x
, maybe [] (schemaTypeToXML "currencyType") $ quotation_currencyType x
, maybe [] (schemaTypeToXML "timing") $ quotation_timing x
, maybe [] (foldOneOf2 (schemaTypeToXML "businessCenter")
(schemaTypeToXML "exchangeId")
) $ quotation_choice7 x
, concatMap (schemaTypeToXML "informationSource") $ quotation_informationSource x
, maybe [] (schemaTypeToXML "pricingModel") $ quotation_pricingModel x
, maybe [] (schemaTypeToXML "time") $ quotation_time x
, maybe [] (schemaTypeToXML "valuationDate") $ quotation_valuationDate x
, maybe [] (schemaTypeToXML "expiryTime") $ quotation_expiryTime x
, maybe [] (schemaTypeToXML "cashflowType") $ quotation_cashflowType x
, concatMap (schemaTypeToXML "sensitivitySet") $ quotation_sensitivitySet x
]
data ReportingRoles = ReportingRoles
{ reportRoles_baseParty :: Maybe PartyReference
, reportRoles_baseAccount :: Maybe AccountReference
, reportRoles_activityProvider :: Maybe PartyReference
, reportRoles_positionProvider :: Maybe PartyReference
, reportRoles_valuationProvider :: Maybe PartyReference
}
deriving (Eq,Show)
instance SchemaType ReportingRoles where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return ReportingRoles
`apply` optional (parseSchemaType "baseParty")
`apply` optional (parseSchemaType "baseAccount")
`apply` optional (parseSchemaType "activityProvider")
`apply` optional (parseSchemaType "positionProvider")
`apply` optional (parseSchemaType "valuationProvider")
schemaTypeToXML s x@ReportingRoles{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "baseParty") $ reportRoles_baseParty x
, maybe [] (schemaTypeToXML "baseAccount") $ reportRoles_baseAccount x
, maybe [] (schemaTypeToXML "activityProvider") $ reportRoles_activityProvider x
, maybe [] (schemaTypeToXML "positionProvider") $ reportRoles_positionProvider x
, maybe [] (schemaTypeToXML "valuationProvider") $ reportRoles_valuationProvider x
]
data ScheduledDate = ScheduledDate
{ schedDate_choice0 :: (Maybe (OneOf1 ((Maybe (Xsd.Date)),(Maybe (Xsd.Date)))))
, schedDate_type :: Maybe ScheduledDateType
, schedDate_assetReference :: Maybe AnyAssetReference
, schedDate_choice3 :: (Maybe (OneOf2 AssetValuation ValuationReference))
}
deriving (Eq,Show)
instance SchemaType ScheduledDate where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return ScheduledDate
`apply` optional (oneOf' [ ("Maybe Xsd.Date Maybe Xsd.Date", fmap OneOf1 (return (,) `apply` optional (parseSchemaType "unadjustedDate")
`apply` optional (parseSchemaType "adjustedDate")))
])
`apply` optional (parseSchemaType "type")
`apply` optional (parseSchemaType "assetReference")
`apply` optional (oneOf' [ ("AssetValuation", fmap OneOf2 (parseSchemaType "associatedValue"))
, ("ValuationReference", fmap TwoOf2 (parseSchemaType "associatedValueReference"))
])
schemaTypeToXML s x@ScheduledDate{} =
toXMLElement s []
[ maybe [] (foldOneOf1 (\ (a,b) -> concat [ maybe [] (schemaTypeToXML "unadjustedDate") a
, maybe [] (schemaTypeToXML "adjustedDate") b
])
) $ schedDate_choice0 x
, maybe [] (schemaTypeToXML "type") $ schedDate_type x
, maybe [] (schemaTypeToXML "assetReference") $ schedDate_assetReference x
, maybe [] (foldOneOf2 (schemaTypeToXML "associatedValue")
(schemaTypeToXML "associatedValueReference")
) $ schedDate_choice3 x
]
data ScheduledDates = ScheduledDates
{ schedDates_scheduledDate :: [ScheduledDate]
}
deriving (Eq,Show)
instance SchemaType ScheduledDates where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return ScheduledDates
`apply` many (parseSchemaType "scheduledDate")
schemaTypeToXML s x@ScheduledDates{} =
toXMLElement s []
[ concatMap (schemaTypeToXML "scheduledDate") $ schedDates_scheduledDate x
]
data ScheduledDateType = ScheduledDateType Scheme ScheduledDateTypeAttributes deriving (Eq,Show)
data ScheduledDateTypeAttributes = ScheduledDateTypeAttributes
{ schedDateTypeAttrib_scheduledDateTypeScheme :: Maybe Xsd.AnyURI
}
deriving (Eq,Show)
instance SchemaType ScheduledDateType where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ do
a0 <- optional $ getAttribute "scheduledDateTypeScheme" e pos
reparse [CElem e pos]
v <- parseSchemaType s
return $ ScheduledDateType v (ScheduledDateTypeAttributes a0)
schemaTypeToXML s (ScheduledDateType bt at) =
addXMLAttributes [ maybe [] (toXMLAttribute "scheduledDateTypeScheme") $ schedDateTypeAttrib_scheduledDateTypeScheme at
]
$ schemaTypeToXML s bt
instance Extension ScheduledDateType Scheme where
supertype (ScheduledDateType s _) = s
data Sensitivity = Sensitivity Xsd.Decimal SensitivityAttributes deriving (Eq,Show)
data SensitivityAttributes = SensitivityAttributes
{ sensitAttrib_name :: Maybe Xsd.NormalizedString
, sensitAttrib_definitionRef :: Maybe Xsd.IDREF
}
deriving (Eq,Show)
instance SchemaType Sensitivity where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ do
a0 <- optional $ getAttribute "name" e pos
a1 <- optional $ getAttribute "definitionRef" e pos
reparse [CElem e pos]
v <- parseSchemaType s
return $ Sensitivity v (SensitivityAttributes a0 a1)
schemaTypeToXML s (Sensitivity bt at) =
addXMLAttributes [ maybe [] (toXMLAttribute "name") $ sensitAttrib_name at
, maybe [] (toXMLAttribute "definitionRef") $ sensitAttrib_definitionRef at
]
$ schemaTypeToXML s bt
instance Extension Sensitivity Xsd.Decimal where
supertype (Sensitivity s _) = s
data SensitivitySet = SensitivitySet
{ sensitSet_ID :: Maybe Xsd.ID
, sensitSet_name :: Maybe Xsd.XsdString
, sensitSet_definitionReference :: Maybe SensitivitySetDefinitionReference
, sensitSet_sensitivity :: [Sensitivity]
}
deriving (Eq,Show)
instance SchemaType SensitivitySet where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (SensitivitySet a0)
`apply` optional (parseSchemaType "name")
`apply` optional (parseSchemaType "definitionReference")
`apply` many (parseSchemaType "sensitivity")
schemaTypeToXML s x@SensitivitySet{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ sensitSet_ID x
]
[ maybe [] (schemaTypeToXML "name") $ sensitSet_name x
, maybe [] (schemaTypeToXML "definitionReference") $ sensitSet_definitionReference x
, concatMap (schemaTypeToXML "sensitivity") $ sensitSet_sensitivity x
]
data Valuations = Valuations
{ valuations_choice0 :: (Maybe (OneOf2 AssetValuation ValuationReference))
}
deriving (Eq,Show)
instance SchemaType Valuations where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return Valuations
`apply` optional (oneOf' [ ("AssetValuation", fmap OneOf2 (parseSchemaType "valuation"))
, ("ValuationReference", fmap TwoOf2 (parseSchemaType "valuationReference"))
])
schemaTypeToXML s x@Valuations{} =
toXMLElement s []
[ maybe [] (foldOneOf2 (schemaTypeToXML "valuation")
(schemaTypeToXML "valuationReference")
) $ valuations_choice0 x
]
data ValuationSet = ValuationSet
{ valuationSet_ID :: Maybe Xsd.ID
, valuationSet_name :: Maybe Xsd.XsdString
, valuationSet_valuationScenario :: [ValuationScenario]
, valuationSet_valuationScenarioReference :: [ValuationScenarioReference]
, valuationSet_baseParty :: Maybe PartyReference
, valuationSet_quotationCharacteristics :: [QuotationCharacteristics]
, valuationSet_sensitivitySetDefinition :: [SensitivitySetDefinition]
, valuationSet_detail :: Maybe ValuationSetDetail
, valuationSet_assetValuation :: [AssetValuation]
}
deriving (Eq,Show)
instance SchemaType ValuationSet where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (ValuationSet a0)
`apply` optional (parseSchemaType "name")
`apply` many (parseSchemaType "valuationScenario")
`apply` many (parseSchemaType "valuationScenarioReference")
`apply` optional (parseSchemaType "baseParty")
`apply` many (parseSchemaType "quotationCharacteristics")
`apply` many (parseSchemaType "sensitivitySetDefinition")
`apply` optional (parseSchemaType "detail")
`apply` many (parseSchemaType "assetValuation")
schemaTypeToXML s x@ValuationSet{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ valuationSet_ID x
]
[ maybe [] (schemaTypeToXML "name") $ valuationSet_name x
, concatMap (schemaTypeToXML "valuationScenario") $ valuationSet_valuationScenario x
, concatMap (schemaTypeToXML "valuationScenarioReference") $ valuationSet_valuationScenarioReference x
, maybe [] (schemaTypeToXML "baseParty") $ valuationSet_baseParty x
, concatMap (schemaTypeToXML "quotationCharacteristics") $ valuationSet_quotationCharacteristics x
, concatMap (schemaTypeToXML "sensitivitySetDefinition") $ valuationSet_sensitivitySetDefinition x
, maybe [] (schemaTypeToXML "detail") $ valuationSet_detail x
, concatMap (schemaTypeToXML "assetValuation") $ valuationSet_assetValuation x
]
data ValuationSetDetail = ValuationSetDetail Scheme ValuationSetDetailAttributes deriving (Eq,Show)
data ValuationSetDetailAttributes = ValuationSetDetailAttributes
{ valSetDetailAttrib_valuationSetDetailScheme :: Maybe Xsd.AnyURI
}
deriving (Eq,Show)
instance SchemaType ValuationSetDetail where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ do
a0 <- optional $ getAttribute "valuationSetDetailScheme" e pos
reparse [CElem e pos]
v <- parseSchemaType s
return $ ValuationSetDetail v (ValuationSetDetailAttributes a0)
schemaTypeToXML s (ValuationSetDetail bt at) =
addXMLAttributes [ maybe [] (toXMLAttribute "valuationSetDetailScheme") $ valSetDetailAttrib_valuationSetDetailScheme at
]
$ schemaTypeToXML s bt
instance Extension ValuationSetDetail Scheme where
supertype (ValuationSetDetail s _) = s
elementValuationSet :: XMLParser ValuationSet
elementValuationSet = parseSchemaType "valuationSet"
elementToXMLValuationSet :: ValuationSet -> [Content ()]
elementToXMLValuationSet = schemaTypeToXML "valuationSet"
data Position = Position
{ position_ID :: Maybe Xsd.ID
, position_id :: Maybe PositionId
, position_version :: Maybe Xsd.PositiveInteger
, position_status :: Maybe PositionStatusEnum
, position_creationDate :: Maybe Xsd.Date
, position_originatingEvent :: Maybe PositionOriginEnum
, position_history :: Maybe PositionHistory
, position_reportingRoles :: Maybe ReportingRoles
, position_constituent :: Maybe PositionConstituent
, position_scheduledDate :: [ScheduledDate]
, position_valuation :: [AssetValuation]
}
deriving (Eq,Show)
instance SchemaType Position where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (Position a0)
`apply` optional (parseSchemaType "positionId")
`apply` optional (parseSchemaType "version")
`apply` optional (parseSchemaType "status")
`apply` optional (parseSchemaType "creationDate")
`apply` optional (parseSchemaType "originatingEvent")
`apply` optional (parseSchemaType "history")
`apply` optional (parseSchemaType "reportingRoles")
`apply` optional (parseSchemaType "constituent")
`apply` many (parseSchemaType "scheduledDate")
`apply` many (parseSchemaType "valuation")
schemaTypeToXML s x@Position{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ position_ID x
]
[ maybe [] (schemaTypeToXML "positionId") $ position_id x
, maybe [] (schemaTypeToXML "version") $ position_version x
, maybe [] (schemaTypeToXML "status") $ position_status x
, maybe [] (schemaTypeToXML "creationDate") $ position_creationDate x
, maybe [] (schemaTypeToXML "originatingEvent") $ position_originatingEvent x
, maybe [] (schemaTypeToXML "history") $ position_history x
, maybe [] (schemaTypeToXML "reportingRoles") $ position_reportingRoles x
, maybe [] (schemaTypeToXML "constituent") $ position_constituent x
, concatMap (schemaTypeToXML "scheduledDate") $ position_scheduledDate x
, concatMap (schemaTypeToXML "valuation") $ position_valuation x
]
data PositionHistory = PositionHistory
{ positHistory_choice0 :: (Maybe (OneOf10 ((Maybe (OriginatingEvent)),(Maybe (Trade))) TradeAmendmentContent TradeNotionalChange ((Maybe (TerminatingEvent)),(Maybe (TradeNotionalChange))) TradeNovationContent OptionExercise [OptionExpiry] DeClear Withdrawal AdditionalEvent))
}
deriving (Eq,Show)
instance SchemaType PositionHistory where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return PositionHistory
`apply` optional (oneOf' [ ("Maybe OriginatingEvent Maybe Trade", fmap OneOf10 (return (,) `apply` optional (parseSchemaType "originatingEvent")
`apply` optional (parseSchemaType "trade")))
, ("TradeAmendmentContent", fmap TwoOf10 (parseSchemaType "amendment"))
, ("TradeNotionalChange", fmap ThreeOf10 (parseSchemaType "increase"))
, ("Maybe TerminatingEvent Maybe TradeNotionalChange", fmap FourOf10 (return (,) `apply` optional (parseSchemaType "terminatingEvent")
`apply` optional (parseSchemaType "termination")))
, ("TradeNovationContent", fmap FiveOf10 (parseSchemaType "novation"))
, ("OptionExercise", fmap SixOf10 (parseSchemaType "optionExercise"))
, ("[OptionExpiry]", fmap SevenOf10 (many1 (parseSchemaType "optionExpiry")))
, ("DeClear", fmap EightOf10 (parseSchemaType "deClear"))
, ("Withdrawal", fmap NineOf10 (parseSchemaType "withdrawal"))
, ("AdditionalEvent", fmap TenOf10 (elementAdditionalEvent))
])
schemaTypeToXML s x@PositionHistory{} =
toXMLElement s []
[ maybe [] (foldOneOf10 (\ (a,b) -> concat [ maybe [] (schemaTypeToXML "originatingEvent") a
, maybe [] (schemaTypeToXML "trade") b
])
(schemaTypeToXML "amendment")
(schemaTypeToXML "increase")
(\ (a,b) -> concat [ maybe [] (schemaTypeToXML "terminatingEvent") a
, maybe [] (schemaTypeToXML "termination") b
])
(schemaTypeToXML "novation")
(schemaTypeToXML "optionExercise")
(concatMap (schemaTypeToXML "optionExpiry"))
(schemaTypeToXML "deClear")
(schemaTypeToXML "withdrawal")
(elementToXMLAdditionalEvent)
) $ positHistory_choice0 x
]
data PositionConstituent = PositionConstituent
{ positConstit_choice0 :: (Maybe (OneOf3 Trade Xsd.PositiveInteger PartyTradeIdentifiers))
}
deriving (Eq,Show)
instance SchemaType PositionConstituent where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return PositionConstituent
`apply` optional (oneOf' [ ("Trade", fmap OneOf3 (parseSchemaType "trade"))
, ("Xsd.PositiveInteger", fmap TwoOf3 (parseSchemaType "positionVersionReference"))
, ("PartyTradeIdentifiers", fmap ThreeOf3 (parseSchemaType "tradeReference"))
])
schemaTypeToXML s x@PositionConstituent{} =
toXMLElement s []
[ maybe [] (foldOneOf3 (schemaTypeToXML "trade")
(schemaTypeToXML "positionVersionReference")
(schemaTypeToXML "tradeReference")
) $ positConstit_choice0 x
]